schema_generated.h source code [halide/build-apps/_deps/tflite-src/tensorflow/lite/schema/schema_generated.h]

1	/ Copyright 2018 The TensorFlow Authors. All Rights Reserved.*
2
3	Licensed under the Apache License, Version 2.0 (the "License");
4	you may not use this file except in compliance with the License.
5	You may obtain a copy of the License at
6
7	http://www.apache.org/licenses/LICENSE-2.0
8
9	Unless required by applicable law or agreed to in writing, software
10	distributed under the License is distributed on an "AS IS" BASIS,
11	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	See the License for the specific language governing permissions and
13	limitations under the License.
14	==============================================================================/*
15	// automatically generated by the FlatBuffers compiler, do not modify
16
17
18	#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
19	#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
20
21	#include "flatbuffers/flatbuffers.h"
22
23	namespace tflite {
24
25	struct CustomQuantization;
26	struct CustomQuantizationT;
27
28	struct QuantizationParameters;
29	struct QuantizationParametersT;
30
31	struct Int32Vector;
32	struct Int32VectorT;
33
34	struct Uint16Vector;
35	struct Uint16VectorT;
36
37	struct Uint8Vector;
38	struct Uint8VectorT;
39
40	struct DimensionMetadata;
41	struct DimensionMetadataT;
42
43	struct SparsityParameters;
44	struct SparsityParametersT;
45
46	struct Tensor;
47	struct TensorT;
48
49	struct Conv2DOptions;
50	struct Conv2DOptionsT;
51
52	struct Conv3DOptions;
53	struct Conv3DOptionsT;
54
55	struct Pool2DOptions;
56	struct Pool2DOptionsT;
57
58	struct DepthwiseConv2DOptions;
59	struct DepthwiseConv2DOptionsT;
60
61	struct ConcatEmbeddingsOptions;
62	struct ConcatEmbeddingsOptionsT;
63
64	struct LSHProjectionOptions;
65	struct LSHProjectionOptionsT;
66
67	struct SVDFOptions;
68	struct SVDFOptionsT;
69
70	struct RNNOptions;
71	struct RNNOptionsT;
72
73	struct SequenceRNNOptions;
74	struct SequenceRNNOptionsT;
75
76	struct BidirectionalSequenceRNNOptions;
77	struct BidirectionalSequenceRNNOptionsT;
78
79	struct FullyConnectedOptions;
80	struct FullyConnectedOptionsT;
81
82	struct SoftmaxOptions;
83	struct SoftmaxOptionsT;
84
85	struct ConcatenationOptions;
86	struct ConcatenationOptionsT;
87
88	struct AddOptions;
89	struct AddOptionsT;
90
91	struct MulOptions;
92	struct MulOptionsT;
93
94	struct L2NormOptions;
95	struct L2NormOptionsT;
96
97	struct LocalResponseNormalizationOptions;
98	struct LocalResponseNormalizationOptionsT;
99
100	struct LSTMOptions;
101	struct LSTMOptionsT;
102
103	struct UnidirectionalSequenceLSTMOptions;
104	struct UnidirectionalSequenceLSTMOptionsT;
105
106	struct BidirectionalSequenceLSTMOptions;
107	struct BidirectionalSequenceLSTMOptionsT;
108
109	struct ResizeBilinearOptions;
110	struct ResizeBilinearOptionsT;
111
112	struct ResizeNearestNeighborOptions;
113	struct ResizeNearestNeighborOptionsT;
114
115	struct CallOptions;
116	struct CallOptionsT;
117
118	struct PadOptions;
119	struct PadOptionsT;
120
121	struct PadV2Options;
122	struct PadV2OptionsT;
123
124	struct ReshapeOptions;
125	struct ReshapeOptionsT;
126
127	struct SpaceToBatchNDOptions;
128	struct SpaceToBatchNDOptionsT;
129
130	struct BatchToSpaceNDOptions;
131	struct BatchToSpaceNDOptionsT;
132
133	struct SkipGramOptions;
134	struct SkipGramOptionsT;
135
136	struct SpaceToDepthOptions;
137	struct SpaceToDepthOptionsT;
138
139	struct DepthToSpaceOptions;
140	struct DepthToSpaceOptionsT;
141
142	struct SubOptions;
143	struct SubOptionsT;
144
145	struct DivOptions;
146	struct DivOptionsT;
147
148	struct TopKV2Options;
149	struct TopKV2OptionsT;
150
151	struct EmbeddingLookupSparseOptions;
152	struct EmbeddingLookupSparseOptionsT;
153
154	struct GatherOptions;
155	struct GatherOptionsT;
156
157	struct TransposeOptions;
158	struct TransposeOptionsT;
159
160	struct ExpOptions;
161	struct ExpOptionsT;
162
163	struct CosOptions;
164	struct CosOptionsT;
165
166	struct ReducerOptions;
167	struct ReducerOptionsT;
168
169	struct SqueezeOptions;
170	struct SqueezeOptionsT;
171
172	struct SplitOptions;
173	struct SplitOptionsT;
174
175	struct SplitVOptions;
176	struct SplitVOptionsT;
177
178	struct StridedSliceOptions;
179	struct StridedSliceOptionsT;
180
181	struct LogSoftmaxOptions;
182	struct LogSoftmaxOptionsT;
183
184	struct CastOptions;
185	struct CastOptionsT;
186
187	struct DequantizeOptions;
188	struct DequantizeOptionsT;
189
190	struct MaximumMinimumOptions;
191	struct MaximumMinimumOptionsT;
192
193	struct TileOptions;
194	struct TileOptionsT;
195
196	struct ArgMaxOptions;
197	struct ArgMaxOptionsT;
198
199	struct ArgMinOptions;
200	struct ArgMinOptionsT;
201
202	struct GreaterOptions;
203	struct GreaterOptionsT;
204
205	struct GreaterEqualOptions;
206	struct GreaterEqualOptionsT;
207
208	struct LessOptions;
209	struct LessOptionsT;
210
211	struct LessEqualOptions;
212	struct LessEqualOptionsT;
213
214	struct NegOptions;
215	struct NegOptionsT;
216
217	struct SelectOptions;
218	struct SelectOptionsT;
219
220	struct SliceOptions;
221	struct SliceOptionsT;
222
223	struct TransposeConvOptions;
224	struct TransposeConvOptionsT;
225
226	struct ExpandDimsOptions;
227	struct ExpandDimsOptionsT;
228
229	struct SparseToDenseOptions;
230	struct SparseToDenseOptionsT;
231
232	struct EqualOptions;
233	struct EqualOptionsT;
234
235	struct NotEqualOptions;
236	struct NotEqualOptionsT;
237
238	struct ShapeOptions;
239	struct ShapeOptionsT;
240
241	struct RankOptions;
242	struct RankOptionsT;
243
244	struct PowOptions;
245	struct PowOptionsT;
246
247	struct FakeQuantOptions;
248	struct FakeQuantOptionsT;
249
250	struct PackOptions;
251	struct PackOptionsT;
252
253	struct LogicalOrOptions;
254	struct LogicalOrOptionsT;
255
256	struct OneHotOptions;
257	struct OneHotOptionsT;
258
259	struct AbsOptions;
260	struct AbsOptionsT;
261
262	struct HardSwishOptions;
263	struct HardSwishOptionsT;
264
265	struct LogicalAndOptions;
266	struct LogicalAndOptionsT;
267
268	struct LogicalNotOptions;
269	struct LogicalNotOptionsT;
270
271	struct UnpackOptions;
272	struct UnpackOptionsT;
273
274	struct FloorDivOptions;
275	struct FloorDivOptionsT;
276
277	struct SquareOptions;
278	struct SquareOptionsT;
279
280	struct ZerosLikeOptions;
281	struct ZerosLikeOptionsT;
282
283	struct FillOptions;
284	struct FillOptionsT;
285
286	struct FloorModOptions;
287	struct FloorModOptionsT;
288
289	struct RangeOptions;
290	struct RangeOptionsT;
291
292	struct LeakyReluOptions;
293	struct LeakyReluOptionsT;
294
295	struct SquaredDifferenceOptions;
296	struct SquaredDifferenceOptionsT;
297
298	struct MirrorPadOptions;
299	struct MirrorPadOptionsT;
300
301	struct UniqueOptions;
302	struct UniqueOptionsT;
303
304	struct ReverseV2Options;
305	struct ReverseV2OptionsT;
306
307	struct AddNOptions;
308	struct AddNOptionsT;
309
310	struct GatherNdOptions;
311	struct GatherNdOptionsT;
312
313	struct WhereOptions;
314	struct WhereOptionsT;
315
316	struct ReverseSequenceOptions;
317	struct ReverseSequenceOptionsT;
318
319	struct MatrixDiagOptions;
320	struct MatrixDiagOptionsT;
321
322	struct QuantizeOptions;
323	struct QuantizeOptionsT;
324
325	struct MatrixSetDiagOptions;
326	struct MatrixSetDiagOptionsT;
327
328	struct IfOptions;
329	struct IfOptionsT;
330
331	struct CallOnceOptions;
332	struct CallOnceOptionsT;
333
334	struct WhileOptions;
335	struct WhileOptionsT;
336
337	struct NonMaxSuppressionV4Options;
338	struct NonMaxSuppressionV4OptionsT;
339
340	struct NonMaxSuppressionV5Options;
341	struct NonMaxSuppressionV5OptionsT;
342
343	struct ScatterNdOptions;
344	struct ScatterNdOptionsT;
345
346	struct SelectV2Options;
347	struct SelectV2OptionsT;
348
349	struct DensifyOptions;
350	struct DensifyOptionsT;
351
352	struct SegmentSumOptions;
353	struct SegmentSumOptionsT;
354
355	struct BatchMatMulOptions;
356	struct BatchMatMulOptionsT;
357
358	struct CumsumOptions;
359	struct CumsumOptionsT;
360
361	struct BroadcastToOptions;
362	struct BroadcastToOptionsT;
363
364	struct Rfft2dOptions;
365	struct Rfft2dOptionsT;
366
367	struct HashtableOptions;
368	struct HashtableOptionsT;
369
370	struct HashtableFindOptions;
371	struct HashtableFindOptionsT;
372
373	struct HashtableImportOptions;
374	struct HashtableImportOptionsT;
375
376	struct HashtableSizeOptions;
377	struct HashtableSizeOptionsT;
378
379	struct OperatorCode;
380	struct OperatorCodeT;
381
382	struct Operator;
383	struct OperatorT;
384
385	struct SubGraph;
386	struct SubGraphT;
387
388	struct Buffer;
389	struct BufferT;
390
391	struct Metadata;
392	struct MetadataT;
393
394	struct TensorMap;
395	struct TensorMapT;
396
397	struct SignatureDef;
398	struct SignatureDefT;
399
400	struct Model;
401	struct ModelT;
402
403	enum TensorType {
404	TensorType_FLOAT32 = `0`,
405	TensorType_FLOAT16 = `1`,
406	TensorType_INT32 = `2`,
407	TensorType_UINT8 = `3`,
408	TensorType_INT64 = `4`,
409	TensorType_STRING = `5`,
410	TensorType_BOOL = `6`,
411	TensorType_INT16 = `7`,
412	TensorType_COMPLEX64 = `8`,
413	TensorType_INT8 = `9`,
414	TensorType_FLOAT64 = `10`,
415	TensorType_COMPLEX128 = `11`,
416	TensorType_UINT64 = `12`,
417	TensorType_RESOURCE = `13`,
418	TensorType_VARIANT = `14`,
419	TensorType_UINT32 = `15`,
420	TensorType_MIN = TensorType_FLOAT32,
421	TensorType_MAX = TensorType_UINT32
422	};
423
424	inline const TensorType (&EnumValuesTensorType())[`16`] {
425	static const TensorType values[] = {
426	TensorType_FLOAT32,
427	TensorType_FLOAT16,
428	TensorType_INT32,
429	TensorType_UINT8,
430	TensorType_INT64,
431	TensorType_STRING,
432	TensorType_BOOL,
433	TensorType_INT16,
434	TensorType_COMPLEX64,
435	TensorType_INT8,
436	TensorType_FLOAT64,
437	TensorType_COMPLEX128,
438	TensorType_UINT64,
439	TensorType_RESOURCE,
440	TensorType_VARIANT,
441	TensorType_UINT32
442	};
443	return values;
444	}
445
446	inline const char * const *EnumNamesTensorType() {
447	static const char * const names[`17`] = {
448	"FLOAT32",
449	"FLOAT16",
450	"INT32",
451	"UINT8",
452	"INT64",
453	"STRING",
454	"BOOL",
455	"INT16",
456	"COMPLEX64",
457	"INT8",
458	"FLOAT64",
459	"COMPLEX128",
460	"UINT64",
461	"RESOURCE",
462	"VARIANT",
463	"UINT32",
464	nullptr
465	};
466	return names;
467	}
468
469	inline const char *EnumNameTensorType(TensorType e) {
470	if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT32)) return "";
471	const size_t index = static_cast<size_t>(e);
472	return EnumNamesTensorType()[index];
473	}
474
475	enum QuantizationDetails {
476	QuantizationDetails_NONE = `0`,
477	QuantizationDetails_CustomQuantization = `1`,
478	QuantizationDetails_MIN = QuantizationDetails_NONE,
479	QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
480	};
481
482	inline const QuantizationDetails (&EnumValuesQuantizationDetails())[`2`] {
483	static const QuantizationDetails values[] = {
484	QuantizationDetails_NONE,
485	QuantizationDetails_CustomQuantization
486	};
487	return values;
488	}
489
490	inline const char * const *EnumNamesQuantizationDetails() {
491	static const char * const names[`3`] = {
492	"NONE",
493	"CustomQuantization",
494	nullptr
495	};
496	return names;
497	}
498
499	inline const char *EnumNameQuantizationDetails(QuantizationDetails e) {
500	if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization)) return "";
501	const size_t index = static_cast<size_t>(e);
502	return EnumNamesQuantizationDetails()[index];
503	}
504
505	template<typename T> struct QuantizationDetailsTraits {
506	static const QuantizationDetails enum_value = QuantizationDetails_NONE;
507	};
508
509	template<> struct QuantizationDetailsTraits<tflite::CustomQuantization> {
510	static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
511	};
512
513	struct QuantizationDetailsUnion {
514	QuantizationDetails type;
515	void *value;
516
517	QuantizationDetailsUnion() : type(QuantizationDetails_NONE), value(nullptr) {}
518	QuantizationDetailsUnion(QuantizationDetailsUnion&& u) FLATBUFFERS_NOEXCEPT :
519	type(QuantizationDetails_NONE), value(nullptr)
520	{ std::swap(type, u.type); std::swap(value, u.value); }
521	QuantizationDetailsUnion(const QuantizationDetailsUnion &) FLATBUFFERS_NOEXCEPT;
522	QuantizationDetailsUnion &operator=(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT
523	{ QuantizationDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
524	QuantizationDetailsUnion &operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
525	{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
526	~QuantizationDetailsUnion() { Reset(); }
527
528	void Reset();
529
530	#ifndef FLATBUFFERS_CPP98_STL
531	template <typename T>
532	void Set(T&& val) {
533	using RT = typename std::remove_reference<T>::type;
534	Reset();
535	type = QuantizationDetailsTraits<typename RT::TableType>::enum_value;
536	if (type != QuantizationDetails_NONE) {
537	value = new RT(std::forward<T>(val));
538	}
539	}
540	#endif // FLATBUFFERS_CPP98_STL
541
542	static void UnPack(const* void obj, QuantizationDetails type, const* flatbuffers::resolver_function_t *resolver);
543	flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher = nullptr) const*;
544
545	tflite::CustomQuantizationT *AsCustomQuantization() {
546	return type == QuantizationDetails_CustomQuantization ?
547	reinterpret_cast<tflite::CustomQuantizationT >(value) : nullptr*;
548	}
549	const tflite::CustomQuantizationT AsCustomQuantization() const* {
550	return type == QuantizationDetails_CustomQuantization ?
551	reinterpret_cast<const tflite::CustomQuantizationT >(value) : nullptr*;
552	}
553	};
554
555	bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
556	bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types);
557
558	enum DimensionType {
559	DimensionType_DENSE = `0`,
560	DimensionType_SPARSE_CSR = `1`,
561	DimensionType_MIN = DimensionType_DENSE,
562	DimensionType_MAX = DimensionType_SPARSE_CSR
563	};
564
565	inline const DimensionType (&EnumValuesDimensionType())[`2`] {
566	static const DimensionType values[] = {
567	DimensionType_DENSE,
568	DimensionType_SPARSE_CSR
569	};
570	return values;
571	}
572
573	inline const char * const *EnumNamesDimensionType() {
574	static const char * const names[`3`] = {
575	"DENSE",
576	"SPARSE_CSR",
577	nullptr
578	};
579	return names;
580	}
581
582	inline const char *EnumNameDimensionType(DimensionType e) {
583	if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR)) return "";
584	const size_t index = static_cast<size_t>(e);
585	return EnumNamesDimensionType()[index];
586	}
587
588	enum SparseIndexVector {
589	SparseIndexVector_NONE = `0`,
590	SparseIndexVector_Int32Vector = `1`,
591	SparseIndexVector_Uint16Vector = `2`,
592	SparseIndexVector_Uint8Vector = `3`,
593	SparseIndexVector_MIN = SparseIndexVector_NONE,
594	SparseIndexVector_MAX = SparseIndexVector_Uint8Vector
595	};
596
597	inline const SparseIndexVector (&EnumValuesSparseIndexVector())[`4`] {
598	static const SparseIndexVector values[] = {
599	SparseIndexVector_NONE,
600	SparseIndexVector_Int32Vector,
601	SparseIndexVector_Uint16Vector,
602	SparseIndexVector_Uint8Vector
603	};
604	return values;
605	}
606
607	inline const char * const *EnumNamesSparseIndexVector() {
608	static const char * const names[`5`] = {
609	"NONE",
610	"Int32Vector",
611	"Uint16Vector",
612	"Uint8Vector",
613	nullptr
614	};
615	return names;
616	}
617
618	inline const char *EnumNameSparseIndexVector(SparseIndexVector e) {
619	if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector)) return "";
620	const size_t index = static_cast<size_t>(e);
621	return EnumNamesSparseIndexVector()[index];
622	}
623
624	template<typename T> struct SparseIndexVectorTraits {
625	static const SparseIndexVector enum_value = SparseIndexVector_NONE;
626	};
627
628	template<> struct SparseIndexVectorTraits<tflite::Int32Vector> {
629	static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
630	};
631
632	template<> struct SparseIndexVectorTraits<tflite::Uint16Vector> {
633	static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
634	};
635
636	template<> struct SparseIndexVectorTraits<tflite::Uint8Vector> {
637	static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
638	};
639
640	struct SparseIndexVectorUnion {
641	SparseIndexVector type;
642	void *value;
643
644	SparseIndexVectorUnion() : type(SparseIndexVector_NONE), value(nullptr) {}
645	SparseIndexVectorUnion(SparseIndexVectorUnion&& u) FLATBUFFERS_NOEXCEPT :
646	type(SparseIndexVector_NONE), value(nullptr)
647	{ std::swap(type, u.type); std::swap(value, u.value); }
648	SparseIndexVectorUnion(const SparseIndexVectorUnion &) FLATBUFFERS_NOEXCEPT;
649	SparseIndexVectorUnion &operator=(const SparseIndexVectorUnion &u) FLATBUFFERS_NOEXCEPT
650	{ SparseIndexVectorUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
651	SparseIndexVectorUnion &operator=(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
652	{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
653	~SparseIndexVectorUnion() { Reset(); }
654
655	void Reset();
656
657	#ifndef FLATBUFFERS_CPP98_STL
658	template <typename T>
659	void Set(T&& val) {
660	using RT = typename std::remove_reference<T>::type;
661	Reset();
662	type = SparseIndexVectorTraits<typename RT::TableType>::enum_value;
663	if (type != SparseIndexVector_NONE) {
664	value = new RT(std::forward<T>(val));
665	}
666	}
667	#endif // FLATBUFFERS_CPP98_STL
668
669	static void UnPack(const* void obj, SparseIndexVector type, const* flatbuffers::resolver_function_t *resolver);
670	flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher = nullptr) const*;
671
672	tflite::Int32VectorT *AsInt32Vector() {
673	return type == SparseIndexVector_Int32Vector ?
674	reinterpret_cast<tflite::Int32VectorT >(value) : nullptr*;
675	}
676	const tflite::Int32VectorT AsInt32Vector() const* {
677	return type == SparseIndexVector_Int32Vector ?
678	reinterpret_cast<const tflite::Int32VectorT >(value) : nullptr*;
679	}
680	tflite::Uint16VectorT *AsUint16Vector() {
681	return type == SparseIndexVector_Uint16Vector ?
682	reinterpret_cast<tflite::Uint16VectorT >(value) : nullptr*;
683	}
684	const tflite::Uint16VectorT AsUint16Vector() const* {
685	return type == SparseIndexVector_Uint16Vector ?
686	reinterpret_cast<const tflite::Uint16VectorT >(value) : nullptr*;
687	}
688	tflite::Uint8VectorT *AsUint8Vector() {
689	return type == SparseIndexVector_Uint8Vector ?
690	reinterpret_cast<tflite::Uint8VectorT >(value) : nullptr*;
691	}
692	const tflite::Uint8VectorT AsUint8Vector() const* {
693	return type == SparseIndexVector_Uint8Vector ?
694	reinterpret_cast<const tflite::Uint8VectorT >(value) : nullptr*;
695	}
696	};
697
698	bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
699	bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types);
700
701	enum BuiltinOperator {
702	BuiltinOperator_ADD = `0`,
703	BuiltinOperator_AVERAGE_POOL_2D = `1`,
704	BuiltinOperator_CONCATENATION = `2`,
705	BuiltinOperator_CONV_2D = `3`,
706	BuiltinOperator_DEPTHWISE_CONV_2D = `4`,
707	BuiltinOperator_DEPTH_TO_SPACE = `5`,
708	BuiltinOperator_DEQUANTIZE = `6`,
709	BuiltinOperator_EMBEDDING_LOOKUP = `7`,
710	BuiltinOperator_FLOOR = `8`,
711	BuiltinOperator_FULLY_CONNECTED = `9`,
712	BuiltinOperator_HASHTABLE_LOOKUP = `10`,
713	BuiltinOperator_L2_NORMALIZATION = `11`,
714	BuiltinOperator_L2_POOL_2D = `12`,
715	BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = `13`,
716	BuiltinOperator_LOGISTIC = `14`,
717	BuiltinOperator_LSH_PROJECTION = `15`,
718	BuiltinOperator_LSTM = `16`,
719	BuiltinOperator_MAX_POOL_2D = `17`,
720	BuiltinOperator_MUL = `18`,
721	BuiltinOperator_RELU = `19`,
722	BuiltinOperator_RELU_N1_TO_1 = `20`,
723	BuiltinOperator_RELU6 = `21`,
724	BuiltinOperator_RESHAPE = `22`,
725	BuiltinOperator_RESIZE_BILINEAR = `23`,
726	BuiltinOperator_RNN = `24`,
727	BuiltinOperator_SOFTMAX = `25`,
728	BuiltinOperator_SPACE_TO_DEPTH = `26`,
729	BuiltinOperator_SVDF = `27`,
730	BuiltinOperator_TANH = `28`,
731	BuiltinOperator_CONCAT_EMBEDDINGS = `29`,
732	BuiltinOperator_SKIP_GRAM = `30`,
733	BuiltinOperator_CALL = `31`,
734	BuiltinOperator_CUSTOM = `32`,
735	BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = `33`,
736	BuiltinOperator_PAD = `34`,
737	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = `35`,
738	BuiltinOperator_GATHER = `36`,
739	BuiltinOperator_BATCH_TO_SPACE_ND = `37`,
740	BuiltinOperator_SPACE_TO_BATCH_ND = `38`,
741	BuiltinOperator_TRANSPOSE = `39`,
742	BuiltinOperator_MEAN = `40`,
743	BuiltinOperator_SUB = `41`,
744	BuiltinOperator_DIV = `42`,
745	BuiltinOperator_SQUEEZE = `43`,
746	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = `44`,
747	BuiltinOperator_STRIDED_SLICE = `45`,
748	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = `46`,
749	BuiltinOperator_EXP = `47`,
750	BuiltinOperator_TOPK_V2 = `48`,
751	BuiltinOperator_SPLIT = `49`,
752	BuiltinOperator_LOG_SOFTMAX = `50`,
753	BuiltinOperator_DELEGATE = `51`,
754	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = `52`,
755	BuiltinOperator_CAST = `53`,
756	BuiltinOperator_PRELU = `54`,
757	BuiltinOperator_MAXIMUM = `55`,
758	BuiltinOperator_ARG_MAX = `56`,
759	BuiltinOperator_MINIMUM = `57`,
760	BuiltinOperator_LESS = `58`,
761	BuiltinOperator_NEG = `59`,
762	BuiltinOperator_PADV2 = `60`,
763	BuiltinOperator_GREATER = `61`,
764	BuiltinOperator_GREATER_EQUAL = `62`,
765	BuiltinOperator_LESS_EQUAL = `63`,
766	BuiltinOperator_SELECT = `64`,
767	BuiltinOperator_SLICE = `65`,
768	BuiltinOperator_SIN = `66`,
769	BuiltinOperator_TRANSPOSE_CONV = `67`,
770	BuiltinOperator_SPARSE_TO_DENSE = `68`,
771	BuiltinOperator_TILE = `69`,
772	BuiltinOperator_EXPAND_DIMS = `70`,
773	BuiltinOperator_EQUAL = `71`,
774	BuiltinOperator_NOT_EQUAL = `72`,
775	BuiltinOperator_LOG = `73`,
776	BuiltinOperator_SUM = `74`,
777	BuiltinOperator_SQRT = `75`,
778	BuiltinOperator_RSQRT = `76`,
779	BuiltinOperator_SHAPE = `77`,
780	BuiltinOperator_POW = `78`,
781	BuiltinOperator_ARG_MIN = `79`,
782	BuiltinOperator_FAKE_QUANT = `80`,
783	BuiltinOperator_REDUCE_PROD = `81`,
784	BuiltinOperator_REDUCE_MAX = `82`,
785	BuiltinOperator_PACK = `83`,
786	BuiltinOperator_LOGICAL_OR = `84`,
787	BuiltinOperator_ONE_HOT = `85`,
788	BuiltinOperator_LOGICAL_AND = `86`,
789	BuiltinOperator_LOGICAL_NOT = `87`,
790	BuiltinOperator_UNPACK = `88`,
791	BuiltinOperator_REDUCE_MIN = `89`,
792	BuiltinOperator_FLOOR_DIV = `90`,
793	BuiltinOperator_REDUCE_ANY = `91`,
794	BuiltinOperator_SQUARE = `92`,
795	BuiltinOperator_ZEROS_LIKE = `93`,
796	BuiltinOperator_FILL = `94`,
797	BuiltinOperator_FLOOR_MOD = `95`,
798	BuiltinOperator_RANGE = `96`,
799	BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = `97`,
800	BuiltinOperator_LEAKY_RELU = `98`,
801	BuiltinOperator_SQUARED_DIFFERENCE = `99`,
802	BuiltinOperator_MIRROR_PAD = `100`,
803	BuiltinOperator_ABS = `101`,
804	BuiltinOperator_SPLIT_V = `102`,
805	BuiltinOperator_UNIQUE = `103`,
806	BuiltinOperator_CEIL = `104`,
807	BuiltinOperator_REVERSE_V2 = `105`,
808	BuiltinOperator_ADD_N = `106`,
809	BuiltinOperator_GATHER_ND = `107`,
810	BuiltinOperator_COS = `108`,
811	BuiltinOperator_WHERE = `109`,
812	BuiltinOperator_RANK = `110`,
813	BuiltinOperator_ELU = `111`,
814	BuiltinOperator_REVERSE_SEQUENCE = `112`,
815	BuiltinOperator_MATRIX_DIAG = `113`,
816	BuiltinOperator_QUANTIZE = `114`,
817	BuiltinOperator_MATRIX_SET_DIAG = `115`,
818	BuiltinOperator_ROUND = `116`,
819	BuiltinOperator_HARD_SWISH = `117`,
820	BuiltinOperator_IF = `118`,
821	BuiltinOperator_WHILE = `119`,
822	BuiltinOperator_NON_MAX_SUPPRESSION_V4 = `120`,
823	BuiltinOperator_NON_MAX_SUPPRESSION_V5 = `121`,
824	BuiltinOperator_SCATTER_ND = `122`,
825	BuiltinOperator_SELECT_V2 = `123`,
826	BuiltinOperator_DENSIFY = `124`,
827	BuiltinOperator_SEGMENT_SUM = `125`,
828	BuiltinOperator_BATCH_MATMUL = `126`,
829	BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES = `127`,
830	BuiltinOperator_CUMSUM = `128`,
831	BuiltinOperator_CALL_ONCE = `129`,
832	BuiltinOperator_BROADCAST_TO = `130`,
833	BuiltinOperator_RFFT2D = `131`,
834	BuiltinOperator_CONV_3D = `132`,
835	BuiltinOperator_IMAG = `133`,
836	BuiltinOperator_REAL = `134`,
837	BuiltinOperator_COMPLEX_ABS = `135`,
838	BuiltinOperator_HASHTABLE = `136`,
839	BuiltinOperator_HASHTABLE_FIND = `137`,
840	BuiltinOperator_HASHTABLE_IMPORT = `138`,
841	BuiltinOperator_HASHTABLE_SIZE = `139`,
842	BuiltinOperator_MIN = BuiltinOperator_ADD,
843	BuiltinOperator_MAX = BuiltinOperator_HASHTABLE_SIZE
844	};
845
846	inline const BuiltinOperator (&EnumValuesBuiltinOperator())[`140`] {
847	static const BuiltinOperator values[] = {
848	BuiltinOperator_ADD,
849	BuiltinOperator_AVERAGE_POOL_2D,
850	BuiltinOperator_CONCATENATION,
851	BuiltinOperator_CONV_2D,
852	BuiltinOperator_DEPTHWISE_CONV_2D,
853	BuiltinOperator_DEPTH_TO_SPACE,
854	BuiltinOperator_DEQUANTIZE,
855	BuiltinOperator_EMBEDDING_LOOKUP,
856	BuiltinOperator_FLOOR,
857	BuiltinOperator_FULLY_CONNECTED,
858	BuiltinOperator_HASHTABLE_LOOKUP,
859	BuiltinOperator_L2_NORMALIZATION,
860	BuiltinOperator_L2_POOL_2D,
861	BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
862	BuiltinOperator_LOGISTIC,
863	BuiltinOperator_LSH_PROJECTION,
864	BuiltinOperator_LSTM,
865	BuiltinOperator_MAX_POOL_2D,
866	BuiltinOperator_MUL,
867	BuiltinOperator_RELU,
868	BuiltinOperator_RELU_N1_TO_1,
869	BuiltinOperator_RELU6,
870	BuiltinOperator_RESHAPE,
871	BuiltinOperator_RESIZE_BILINEAR,
872	BuiltinOperator_RNN,
873	BuiltinOperator_SOFTMAX,
874	BuiltinOperator_SPACE_TO_DEPTH,
875	BuiltinOperator_SVDF,
876	BuiltinOperator_TANH,
877	BuiltinOperator_CONCAT_EMBEDDINGS,
878	BuiltinOperator_SKIP_GRAM,
879	BuiltinOperator_CALL,
880	BuiltinOperator_CUSTOM,
881	BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
882	BuiltinOperator_PAD,
883	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
884	BuiltinOperator_GATHER,
885	BuiltinOperator_BATCH_TO_SPACE_ND,
886	BuiltinOperator_SPACE_TO_BATCH_ND,
887	BuiltinOperator_TRANSPOSE,
888	BuiltinOperator_MEAN,
889	BuiltinOperator_SUB,
890	BuiltinOperator_DIV,
891	BuiltinOperator_SQUEEZE,
892	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
893	BuiltinOperator_STRIDED_SLICE,
894	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
895	BuiltinOperator_EXP,
896	BuiltinOperator_TOPK_V2,
897	BuiltinOperator_SPLIT,
898	BuiltinOperator_LOG_SOFTMAX,
899	BuiltinOperator_DELEGATE,
900	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
901	BuiltinOperator_CAST,
902	BuiltinOperator_PRELU,
903	BuiltinOperator_MAXIMUM,
904	BuiltinOperator_ARG_MAX,
905	BuiltinOperator_MINIMUM,
906	BuiltinOperator_LESS,
907	BuiltinOperator_NEG,
908	BuiltinOperator_PADV2,
909	BuiltinOperator_GREATER,
910	BuiltinOperator_GREATER_EQUAL,
911	BuiltinOperator_LESS_EQUAL,
912	BuiltinOperator_SELECT,
913	BuiltinOperator_SLICE,
914	BuiltinOperator_SIN,
915	BuiltinOperator_TRANSPOSE_CONV,
916	BuiltinOperator_SPARSE_TO_DENSE,
917	BuiltinOperator_TILE,
918	BuiltinOperator_EXPAND_DIMS,
919	BuiltinOperator_EQUAL,
920	BuiltinOperator_NOT_EQUAL,
921	BuiltinOperator_LOG,
922	BuiltinOperator_SUM,
923	BuiltinOperator_SQRT,
924	BuiltinOperator_RSQRT,
925	BuiltinOperator_SHAPE,
926	BuiltinOperator_POW,
927	BuiltinOperator_ARG_MIN,
928	BuiltinOperator_FAKE_QUANT,
929	BuiltinOperator_REDUCE_PROD,
930	BuiltinOperator_REDUCE_MAX,
931	BuiltinOperator_PACK,
932	BuiltinOperator_LOGICAL_OR,
933	BuiltinOperator_ONE_HOT,
934	BuiltinOperator_LOGICAL_AND,
935	BuiltinOperator_LOGICAL_NOT,
936	BuiltinOperator_UNPACK,
937	BuiltinOperator_REDUCE_MIN,
938	BuiltinOperator_FLOOR_DIV,
939	BuiltinOperator_REDUCE_ANY,
940	BuiltinOperator_SQUARE,
941	BuiltinOperator_ZEROS_LIKE,
942	BuiltinOperator_FILL,
943	BuiltinOperator_FLOOR_MOD,
944	BuiltinOperator_RANGE,
945	BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
946	BuiltinOperator_LEAKY_RELU,
947	BuiltinOperator_SQUARED_DIFFERENCE,
948	BuiltinOperator_MIRROR_PAD,
949	BuiltinOperator_ABS,
950	BuiltinOperator_SPLIT_V,
951	BuiltinOperator_UNIQUE,
952	BuiltinOperator_CEIL,
953	BuiltinOperator_REVERSE_V2,
954	BuiltinOperator_ADD_N,
955	BuiltinOperator_GATHER_ND,
956	BuiltinOperator_COS,
957	BuiltinOperator_WHERE,
958	BuiltinOperator_RANK,
959	BuiltinOperator_ELU,
960	BuiltinOperator_REVERSE_SEQUENCE,
961	BuiltinOperator_MATRIX_DIAG,
962	BuiltinOperator_QUANTIZE,
963	BuiltinOperator_MATRIX_SET_DIAG,
964	BuiltinOperator_ROUND,
965	BuiltinOperator_HARD_SWISH,
966	BuiltinOperator_IF,
967	BuiltinOperator_WHILE,
968	BuiltinOperator_NON_MAX_SUPPRESSION_V4,
969	BuiltinOperator_NON_MAX_SUPPRESSION_V5,
970	BuiltinOperator_SCATTER_ND,
971	BuiltinOperator_SELECT_V2,
972	BuiltinOperator_DENSIFY,
973	BuiltinOperator_SEGMENT_SUM,
974	BuiltinOperator_BATCH_MATMUL,
975	BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES,
976	BuiltinOperator_CUMSUM,
977	BuiltinOperator_CALL_ONCE,
978	BuiltinOperator_BROADCAST_TO,
979	BuiltinOperator_RFFT2D,
980	BuiltinOperator_CONV_3D,
981	BuiltinOperator_IMAG,
982	BuiltinOperator_REAL,
983	BuiltinOperator_COMPLEX_ABS,
984	BuiltinOperator_HASHTABLE,
985	BuiltinOperator_HASHTABLE_FIND,
986	BuiltinOperator_HASHTABLE_IMPORT,
987	BuiltinOperator_HASHTABLE_SIZE
988	};
989	return values;
990	}
991
992	inline const char * const *EnumNamesBuiltinOperator() {
993	static const char * const names[`141`] = {
994	"ADD",
995	"AVERAGE_POOL_2D",
996	"CONCATENATION",
997	"CONV_2D",
998	"DEPTHWISE_CONV_2D",
999	"DEPTH_TO_SPACE",
1000	"DEQUANTIZE",
1001	"EMBEDDING_LOOKUP",
1002	"FLOOR",
1003	"FULLY_CONNECTED",
1004	"HASHTABLE_LOOKUP",
1005	"L2_NORMALIZATION",
1006	"L2_POOL_2D",
1007	"LOCAL_RESPONSE_NORMALIZATION",
1008	"LOGISTIC",
1009	"LSH_PROJECTION",
1010	"LSTM",
1011	"MAX_POOL_2D",
1012	"MUL",
1013	"RELU",
1014	"RELU_N1_TO_1",
1015	"RELU6",
1016	"RESHAPE",
1017	"RESIZE_BILINEAR",
1018	"RNN",
1019	"SOFTMAX",
1020	"SPACE_TO_DEPTH",
1021	"SVDF",
1022	"TANH",
1023	"CONCAT_EMBEDDINGS",
1024	"SKIP_GRAM",
1025	"CALL",
1026	"CUSTOM",
1027	"EMBEDDING_LOOKUP_SPARSE",
1028	"PAD",
1029	"UNIDIRECTIONAL_SEQUENCE_RNN",
1030	"GATHER",
1031	"BATCH_TO_SPACE_ND",
1032	"SPACE_TO_BATCH_ND",
1033	"TRANSPOSE",
1034	"MEAN",
1035	"SUB",
1036	"DIV",
1037	"SQUEEZE",
1038	"UNIDIRECTIONAL_SEQUENCE_LSTM",
1039	"STRIDED_SLICE",
1040	"BIDIRECTIONAL_SEQUENCE_RNN",
1041	"EXP",
1042	"TOPK_V2",
1043	"SPLIT",
1044	"LOG_SOFTMAX",
1045	"DELEGATE",
1046	"BIDIRECTIONAL_SEQUENCE_LSTM",
1047	"CAST",
1048	"PRELU",
1049	"MAXIMUM",
1050	"ARG_MAX",
1051	"MINIMUM",
1052	"LESS",
1053	"NEG",
1054	"PADV2",
1055	"GREATER",
1056	"GREATER_EQUAL",
1057	"LESS_EQUAL",
1058	"SELECT",
1059	"SLICE",
1060	"SIN",
1061	"TRANSPOSE_CONV",
1062	"SPARSE_TO_DENSE",
1063	"TILE",
1064	"EXPAND_DIMS",
1065	"EQUAL",
1066	"NOT_EQUAL",
1067	"LOG",
1068	"SUM",
1069	"SQRT",
1070	"RSQRT",
1071	"SHAPE",
1072	"POW",
1073	"ARG_MIN",
1074	"FAKE_QUANT",
1075	"REDUCE_PROD",
1076	"REDUCE_MAX",
1077	"PACK",
1078	"LOGICAL_OR",
1079	"ONE_HOT",
1080	"LOGICAL_AND",
1081	"LOGICAL_NOT",
1082	"UNPACK",
1083	"REDUCE_MIN",
1084	"FLOOR_DIV",
1085	"REDUCE_ANY",
1086	"SQUARE",
1087	"ZEROS_LIKE",
1088	"FILL",
1089	"FLOOR_MOD",
1090	"RANGE",
1091	"RESIZE_NEAREST_NEIGHBOR",
1092	"LEAKY_RELU",
1093	"SQUARED_DIFFERENCE",
1094	"MIRROR_PAD",
1095	"ABS",
1096	"SPLIT_V",
1097	"UNIQUE",
1098	"CEIL",
1099	"REVERSE_V2",
1100	"ADD_N",
1101	"GATHER_ND",
1102	"COS",
1103	"WHERE",
1104	"RANK",
1105	"ELU",
1106	"REVERSE_SEQUENCE",
1107	"MATRIX_DIAG",
1108	"QUANTIZE",
1109	"MATRIX_SET_DIAG",
1110	"ROUND",
1111	"HARD_SWISH",
1112	"IF",
1113	"WHILE",
1114	"NON_MAX_SUPPRESSION_V4",
1115	"NON_MAX_SUPPRESSION_V5",
1116	"SCATTER_ND",
1117	"SELECT_V2",
1118	"DENSIFY",
1119	"SEGMENT_SUM",
1120	"BATCH_MATMUL",
1121	"PLACEHOLDER_FOR_GREATER_OP_CODES",
1122	"CUMSUM",
1123	"CALL_ONCE",
1124	"BROADCAST_TO",
1125	"RFFT2D",
1126	"CONV_3D",
1127	"IMAG",
1128	"REAL",
1129	"COMPLEX_ABS",
1130	"HASHTABLE",
1131	"HASHTABLE_FIND",
1132	"HASHTABLE_IMPORT",
1133	"HASHTABLE_SIZE",
1134	nullptr
1135	};
1136	return names;
1137	}
1138
1139	inline const char *EnumNameBuiltinOperator(BuiltinOperator e) {
1140	if (flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_HASHTABLE_SIZE)) return "";
1141	const size_t index = static_cast<size_t>(e);
1142	return EnumNamesBuiltinOperator()[index];
1143	}
1144
1145	enum BuiltinOptions {
1146	BuiltinOptions_NONE = `0`,
1147	BuiltinOptions_Conv2DOptions = `1`,
1148	BuiltinOptions_DepthwiseConv2DOptions = `2`,
1149	BuiltinOptions_ConcatEmbeddingsOptions = `3`,
1150	BuiltinOptions_LSHProjectionOptions = `4`,
1151	BuiltinOptions_Pool2DOptions = `5`,
1152	BuiltinOptions_SVDFOptions = `6`,
1153	BuiltinOptions_RNNOptions = `7`,
1154	BuiltinOptions_FullyConnectedOptions = `8`,
1155	BuiltinOptions_SoftmaxOptions = `9`,
1156	BuiltinOptions_ConcatenationOptions = `10`,
1157	BuiltinOptions_AddOptions = `11`,
1158	BuiltinOptions_L2NormOptions = `12`,
1159	BuiltinOptions_LocalResponseNormalizationOptions = `13`,
1160	BuiltinOptions_LSTMOptions = `14`,
1161	BuiltinOptions_ResizeBilinearOptions = `15`,
1162	BuiltinOptions_CallOptions = `16`,
1163	BuiltinOptions_ReshapeOptions = `17`,
1164	BuiltinOptions_SkipGramOptions = `18`,
1165	BuiltinOptions_SpaceToDepthOptions = `19`,
1166	BuiltinOptions_EmbeddingLookupSparseOptions = `20`,
1167	BuiltinOptions_MulOptions = `21`,
1168	BuiltinOptions_PadOptions = `22`,
1169	BuiltinOptions_GatherOptions = `23`,
1170	BuiltinOptions_BatchToSpaceNDOptions = `24`,
1171	BuiltinOptions_SpaceToBatchNDOptions = `25`,
1172	BuiltinOptions_TransposeOptions = `26`,
1173	BuiltinOptions_ReducerOptions = `27`,
1174	BuiltinOptions_SubOptions = `28`,
1175	BuiltinOptions_DivOptions = `29`,
1176	BuiltinOptions_SqueezeOptions = `30`,
1177	BuiltinOptions_SequenceRNNOptions = `31`,
1178	BuiltinOptions_StridedSliceOptions = `32`,
1179	BuiltinOptions_ExpOptions = `33`,
1180	BuiltinOptions_TopKV2Options = `34`,
1181	BuiltinOptions_SplitOptions = `35`,
1182	BuiltinOptions_LogSoftmaxOptions = `36`,
1183	BuiltinOptions_CastOptions = `37`,
1184	BuiltinOptions_DequantizeOptions = `38`,
1185	BuiltinOptions_MaximumMinimumOptions = `39`,
1186	BuiltinOptions_ArgMaxOptions = `40`,
1187	BuiltinOptions_LessOptions = `41`,
1188	BuiltinOptions_NegOptions = `42`,
1189	BuiltinOptions_PadV2Options = `43`,
1190	BuiltinOptions_GreaterOptions = `44`,
1191	BuiltinOptions_GreaterEqualOptions = `45`,
1192	BuiltinOptions_LessEqualOptions = `46`,
1193	BuiltinOptions_SelectOptions = `47`,
1194	BuiltinOptions_SliceOptions = `48`,
1195	BuiltinOptions_TransposeConvOptions = `49`,
1196	BuiltinOptions_SparseToDenseOptions = `50`,
1197	BuiltinOptions_TileOptions = `51`,
1198	BuiltinOptions_ExpandDimsOptions = `52`,
1199	BuiltinOptions_EqualOptions = `53`,
1200	BuiltinOptions_NotEqualOptions = `54`,
1201	BuiltinOptions_ShapeOptions = `55`,
1202	BuiltinOptions_PowOptions = `56`,
1203	BuiltinOptions_ArgMinOptions = `57`,
1204	BuiltinOptions_FakeQuantOptions = `58`,
1205	BuiltinOptions_PackOptions = `59`,
1206	BuiltinOptions_LogicalOrOptions = `60`,
1207	BuiltinOptions_OneHotOptions = `61`,
1208	BuiltinOptions_LogicalAndOptions = `62`,
1209	BuiltinOptions_LogicalNotOptions = `63`,
1210	BuiltinOptions_UnpackOptions = `64`,
1211	BuiltinOptions_FloorDivOptions = `65`,
1212	BuiltinOptions_SquareOptions = `66`,
1213	BuiltinOptions_ZerosLikeOptions = `67`,
1214	BuiltinOptions_FillOptions = `68`,
1215	BuiltinOptions_BidirectionalSequenceLSTMOptions = `69`,
1216	BuiltinOptions_BidirectionalSequenceRNNOptions = `70`,
1217	BuiltinOptions_UnidirectionalSequenceLSTMOptions = `71`,
1218	BuiltinOptions_FloorModOptions = `72`,
1219	BuiltinOptions_RangeOptions = `73`,
1220	BuiltinOptions_ResizeNearestNeighborOptions = `74`,
1221	BuiltinOptions_LeakyReluOptions = `75`,
1222	BuiltinOptions_SquaredDifferenceOptions = `76`,
1223	BuiltinOptions_MirrorPadOptions = `77`,
1224	BuiltinOptions_AbsOptions = `78`,
1225	BuiltinOptions_SplitVOptions = `79`,
1226	BuiltinOptions_UniqueOptions = `80`,
1227	BuiltinOptions_ReverseV2Options = `81`,
1228	BuiltinOptions_AddNOptions = `82`,
1229	BuiltinOptions_GatherNdOptions = `83`,
1230	BuiltinOptions_CosOptions = `84`,
1231	BuiltinOptions_WhereOptions = `85`,
1232	BuiltinOptions_RankOptions = `86`,
1233	BuiltinOptions_ReverseSequenceOptions = `87`,
1234	BuiltinOptions_MatrixDiagOptions = `88`,
1235	BuiltinOptions_QuantizeOptions = `89`,
1236	BuiltinOptions_MatrixSetDiagOptions = `90`,
1237	BuiltinOptions_HardSwishOptions = `91`,
1238	BuiltinOptions_IfOptions = `92`,
1239	BuiltinOptions_WhileOptions = `93`,
1240	BuiltinOptions_DepthToSpaceOptions = `94`,
1241	BuiltinOptions_NonMaxSuppressionV4Options = `95`,
1242	BuiltinOptions_NonMaxSuppressionV5Options = `96`,
1243	BuiltinOptions_ScatterNdOptions = `97`,
1244	BuiltinOptions_SelectV2Options = `98`,
1245	BuiltinOptions_DensifyOptions = `99`,
1246	BuiltinOptions_SegmentSumOptions = `100`,
1247	BuiltinOptions_BatchMatMulOptions = `101`,
1248	BuiltinOptions_CumsumOptions = `102`,
1249	BuiltinOptions_CallOnceOptions = `103`,
1250	BuiltinOptions_BroadcastToOptions = `104`,
1251	BuiltinOptions_Rfft2dOptions = `105`,
1252	BuiltinOptions_Conv3DOptions = `106`,
1253	BuiltinOptions_HashtableOptions = `107`,
1254	BuiltinOptions_HashtableFindOptions = `108`,
1255	BuiltinOptions_HashtableImportOptions = `109`,
1256	BuiltinOptions_HashtableSizeOptions = `110`,
1257	BuiltinOptions_MIN = BuiltinOptions_NONE,
1258	BuiltinOptions_MAX = BuiltinOptions_HashtableSizeOptions
1259	};
1260
1261	inline const BuiltinOptions (&EnumValuesBuiltinOptions())[`111`] {
1262	static const BuiltinOptions values[] = {
1263	BuiltinOptions_NONE,
1264	BuiltinOptions_Conv2DOptions,
1265	BuiltinOptions_DepthwiseConv2DOptions,
1266	BuiltinOptions_ConcatEmbeddingsOptions,
1267	BuiltinOptions_LSHProjectionOptions,
1268	BuiltinOptions_Pool2DOptions,
1269	BuiltinOptions_SVDFOptions,
1270	BuiltinOptions_RNNOptions,
1271	BuiltinOptions_FullyConnectedOptions,
1272	BuiltinOptions_SoftmaxOptions,
1273	BuiltinOptions_ConcatenationOptions,
1274	BuiltinOptions_AddOptions,
1275	BuiltinOptions_L2NormOptions,
1276	BuiltinOptions_LocalResponseNormalizationOptions,
1277	BuiltinOptions_LSTMOptions,
1278	BuiltinOptions_ResizeBilinearOptions,
1279	BuiltinOptions_CallOptions,
1280	BuiltinOptions_ReshapeOptions,
1281	BuiltinOptions_SkipGramOptions,
1282	BuiltinOptions_SpaceToDepthOptions,
1283	BuiltinOptions_EmbeddingLookupSparseOptions,
1284	BuiltinOptions_MulOptions,
1285	BuiltinOptions_PadOptions,
1286	BuiltinOptions_GatherOptions,
1287	BuiltinOptions_BatchToSpaceNDOptions,
1288	BuiltinOptions_SpaceToBatchNDOptions,
1289	BuiltinOptions_TransposeOptions,
1290	BuiltinOptions_ReducerOptions,
1291	BuiltinOptions_SubOptions,
1292	BuiltinOptions_DivOptions,
1293	BuiltinOptions_SqueezeOptions,
1294	BuiltinOptions_SequenceRNNOptions,
1295	BuiltinOptions_StridedSliceOptions,
1296	BuiltinOptions_ExpOptions,
1297	BuiltinOptions_TopKV2Options,
1298	BuiltinOptions_SplitOptions,
1299	BuiltinOptions_LogSoftmaxOptions,
1300	BuiltinOptions_CastOptions,
1301	BuiltinOptions_DequantizeOptions,
1302	BuiltinOptions_MaximumMinimumOptions,
1303	BuiltinOptions_ArgMaxOptions,
1304	BuiltinOptions_LessOptions,
1305	BuiltinOptions_NegOptions,
1306	BuiltinOptions_PadV2Options,
1307	BuiltinOptions_GreaterOptions,
1308	BuiltinOptions_GreaterEqualOptions,
1309	BuiltinOptions_LessEqualOptions,
1310	BuiltinOptions_SelectOptions,
1311	BuiltinOptions_SliceOptions,
1312	BuiltinOptions_TransposeConvOptions,
1313	BuiltinOptions_SparseToDenseOptions,
1314	BuiltinOptions_TileOptions,
1315	BuiltinOptions_ExpandDimsOptions,
1316	BuiltinOptions_EqualOptions,
1317	BuiltinOptions_NotEqualOptions,
1318	BuiltinOptions_ShapeOptions,
1319	BuiltinOptions_PowOptions,
1320	BuiltinOptions_ArgMinOptions,
1321	BuiltinOptions_FakeQuantOptions,
1322	BuiltinOptions_PackOptions,
1323	BuiltinOptions_LogicalOrOptions,
1324	BuiltinOptions_OneHotOptions,
1325	BuiltinOptions_LogicalAndOptions,
1326	BuiltinOptions_LogicalNotOptions,
1327	BuiltinOptions_UnpackOptions,
1328	BuiltinOptions_FloorDivOptions,
1329	BuiltinOptions_SquareOptions,
1330	BuiltinOptions_ZerosLikeOptions,
1331	BuiltinOptions_FillOptions,
1332	BuiltinOptions_BidirectionalSequenceLSTMOptions,
1333	BuiltinOptions_BidirectionalSequenceRNNOptions,
1334	BuiltinOptions_UnidirectionalSequenceLSTMOptions,
1335	BuiltinOptions_FloorModOptions,
1336	BuiltinOptions_RangeOptions,
1337	BuiltinOptions_ResizeNearestNeighborOptions,
1338	BuiltinOptions_LeakyReluOptions,
1339	BuiltinOptions_SquaredDifferenceOptions,
1340	BuiltinOptions_MirrorPadOptions,
1341	BuiltinOptions_AbsOptions,
1342	BuiltinOptions_SplitVOptions,
1343	BuiltinOptions_UniqueOptions,
1344	BuiltinOptions_ReverseV2Options,
1345	BuiltinOptions_AddNOptions,
1346	BuiltinOptions_GatherNdOptions,
1347	BuiltinOptions_CosOptions,
1348	BuiltinOptions_WhereOptions,
1349	BuiltinOptions_RankOptions,
1350	BuiltinOptions_ReverseSequenceOptions,
1351	BuiltinOptions_MatrixDiagOptions,
1352	BuiltinOptions_QuantizeOptions,
1353	BuiltinOptions_MatrixSetDiagOptions,
1354	BuiltinOptions_HardSwishOptions,
1355	BuiltinOptions_IfOptions,
1356	BuiltinOptions_WhileOptions,
1357	BuiltinOptions_DepthToSpaceOptions,
1358	BuiltinOptions_NonMaxSuppressionV4Options,
1359	BuiltinOptions_NonMaxSuppressionV5Options,
1360	BuiltinOptions_ScatterNdOptions,
1361	BuiltinOptions_SelectV2Options,
1362	BuiltinOptions_DensifyOptions,
1363	BuiltinOptions_SegmentSumOptions,
1364	BuiltinOptions_BatchMatMulOptions,
1365	BuiltinOptions_CumsumOptions,
1366	BuiltinOptions_CallOnceOptions,
1367	BuiltinOptions_BroadcastToOptions,
1368	BuiltinOptions_Rfft2dOptions,
1369	BuiltinOptions_Conv3DOptions,
1370	BuiltinOptions_HashtableOptions,
1371	BuiltinOptions_HashtableFindOptions,
1372	BuiltinOptions_HashtableImportOptions,
1373	BuiltinOptions_HashtableSizeOptions
1374	};
1375	return values;
1376	}
1377
1378	inline const char * const *EnumNamesBuiltinOptions() {
1379	static const char * const names[`112`] = {
1380	"NONE",
1381	"Conv2DOptions",
1382	"DepthwiseConv2DOptions",
1383	"ConcatEmbeddingsOptions",
1384	"LSHProjectionOptions",
1385	"Pool2DOptions",
1386	"SVDFOptions",
1387	"RNNOptions",
1388	"FullyConnectedOptions",
1389	"SoftmaxOptions",
1390	"ConcatenationOptions",
1391	"AddOptions",
1392	"L2NormOptions",
1393	"LocalResponseNormalizationOptions",
1394	"LSTMOptions",
1395	"ResizeBilinearOptions",
1396	"CallOptions",
1397	"ReshapeOptions",
1398	"SkipGramOptions",
1399	"SpaceToDepthOptions",
1400	"EmbeddingLookupSparseOptions",
1401	"MulOptions",
1402	"PadOptions",
1403	"GatherOptions",
1404	"BatchToSpaceNDOptions",
1405	"SpaceToBatchNDOptions",
1406	"TransposeOptions",
1407	"ReducerOptions",
1408	"SubOptions",
1409	"DivOptions",
1410	"SqueezeOptions",
1411	"SequenceRNNOptions",
1412	"StridedSliceOptions",
1413	"ExpOptions",
1414	"TopKV2Options",
1415	"SplitOptions",
1416	"LogSoftmaxOptions",
1417	"CastOptions",
1418	"DequantizeOptions",
1419	"MaximumMinimumOptions",
1420	"ArgMaxOptions",
1421	"LessOptions",
1422	"NegOptions",
1423	"PadV2Options",
1424	"GreaterOptions",
1425	"GreaterEqualOptions",
1426	"LessEqualOptions",
1427	"SelectOptions",
1428	"SliceOptions",
1429	"TransposeConvOptions",
1430	"SparseToDenseOptions",
1431	"TileOptions",
1432	"ExpandDimsOptions",
1433	"EqualOptions",
1434	"NotEqualOptions",
1435	"ShapeOptions",
1436	"PowOptions",
1437	"ArgMinOptions",
1438	"FakeQuantOptions",
1439	"PackOptions",
1440	"LogicalOrOptions",
1441	"OneHotOptions",
1442	"LogicalAndOptions",
1443	"LogicalNotOptions",
1444	"UnpackOptions",
1445	"FloorDivOptions",
1446	"SquareOptions",
1447	"ZerosLikeOptions",
1448	"FillOptions",
1449	"BidirectionalSequenceLSTMOptions",
1450	"BidirectionalSequenceRNNOptions",
1451	"UnidirectionalSequenceLSTMOptions",
1452	"FloorModOptions",
1453	"RangeOptions",
1454	"ResizeNearestNeighborOptions",
1455	"LeakyReluOptions",
1456	"SquaredDifferenceOptions",
1457	"MirrorPadOptions",
1458	"AbsOptions",
1459	"SplitVOptions",
1460	"UniqueOptions",
1461	"ReverseV2Options",
1462	"AddNOptions",
1463	"GatherNdOptions",
1464	"CosOptions",
1465	"WhereOptions",
1466	"RankOptions",
1467	"ReverseSequenceOptions",
1468	"MatrixDiagOptions",
1469	"QuantizeOptions",
1470	"MatrixSetDiagOptions",
1471	"HardSwishOptions",
1472	"IfOptions",
1473	"WhileOptions",
1474	"DepthToSpaceOptions",
1475	"NonMaxSuppressionV4Options",
1476	"NonMaxSuppressionV5Options",
1477	"ScatterNdOptions",
1478	"SelectV2Options",
1479	"DensifyOptions",
1480	"SegmentSumOptions",
1481	"BatchMatMulOptions",
1482	"CumsumOptions",
1483	"CallOnceOptions",
1484	"BroadcastToOptions",
1485	"Rfft2dOptions",
1486	"Conv3DOptions",
1487	"HashtableOptions",
1488	"HashtableFindOptions",
1489	"HashtableImportOptions",
1490	"HashtableSizeOptions",
1491	nullptr
1492	};
1493	return names;
1494	}
1495
1496	inline const char *EnumNameBuiltinOptions(BuiltinOptions e) {
1497	if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_HashtableSizeOptions)) return "";
1498	const size_t index = static_cast<size_t>(e);
1499	return EnumNamesBuiltinOptions()[index];
1500	}
1501
1502	template<typename T> struct BuiltinOptionsTraits {
1503	static const BuiltinOptions enum_value = BuiltinOptions_NONE;
1504	};
1505
1506	template<> struct BuiltinOptionsTraits<tflite::Conv2DOptions> {
1507	static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
1508	};
1509
1510	template<> struct BuiltinOptionsTraits<tflite::DepthwiseConv2DOptions> {
1511	static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
1512	};
1513
1514	template<> struct BuiltinOptionsTraits<tflite::ConcatEmbeddingsOptions> {
1515	static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
1516	};
1517
1518	template<> struct BuiltinOptionsTraits<tflite::LSHProjectionOptions> {
1519	static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
1520	};
1521
1522	template<> struct BuiltinOptionsTraits<tflite::Pool2DOptions> {
1523	static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
1524	};
1525
1526	template<> struct BuiltinOptionsTraits<tflite::SVDFOptions> {
1527	static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
1528	};
1529
1530	template<> struct BuiltinOptionsTraits<tflite::RNNOptions> {
1531	static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
1532	};
1533
1534	template<> struct BuiltinOptionsTraits<tflite::FullyConnectedOptions> {
1535	static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
1536	};
1537
1538	template<> struct BuiltinOptionsTraits<tflite::SoftmaxOptions> {
1539	static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
1540	};
1541
1542	template<> struct BuiltinOptionsTraits<tflite::ConcatenationOptions> {
1543	static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
1544	};
1545
1546	template<> struct BuiltinOptionsTraits<tflite::AddOptions> {
1547	static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
1548	};
1549
1550	template<> struct BuiltinOptionsTraits<tflite::L2NormOptions> {
1551	static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
1552	};
1553
1554	template<> struct BuiltinOptionsTraits<tflite::LocalResponseNormalizationOptions> {
1555	static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
1556	};
1557
1558	template<> struct BuiltinOptionsTraits<tflite::LSTMOptions> {
1559	static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
1560	};
1561
1562	template<> struct BuiltinOptionsTraits<tflite::ResizeBilinearOptions> {
1563	static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
1564	};
1565
1566	template<> struct BuiltinOptionsTraits<tflite::CallOptions> {
1567	static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
1568	};
1569
1570	template<> struct BuiltinOptionsTraits<tflite::ReshapeOptions> {
1571	static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
1572	};
1573
1574	template<> struct BuiltinOptionsTraits<tflite::SkipGramOptions> {
1575	static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
1576	};
1577
1578	template<> struct BuiltinOptionsTraits<tflite::SpaceToDepthOptions> {
1579	static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
1580	};
1581
1582	template<> struct BuiltinOptionsTraits<tflite::EmbeddingLookupSparseOptions> {
1583	static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
1584	};
1585
1586	template<> struct BuiltinOptionsTraits<tflite::MulOptions> {
1587	static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
1588	};
1589
1590	template<> struct BuiltinOptionsTraits<tflite::PadOptions> {
1591	static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
1592	};
1593
1594	template<> struct BuiltinOptionsTraits<tflite::GatherOptions> {
1595	static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
1596	};
1597
1598	template<> struct BuiltinOptionsTraits<tflite::BatchToSpaceNDOptions> {
1599	static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
1600	};
1601
1602	template<> struct BuiltinOptionsTraits<tflite::SpaceToBatchNDOptions> {
1603	static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
1604	};
1605
1606	template<> struct BuiltinOptionsTraits<tflite::TransposeOptions> {
1607	static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
1608	};
1609
1610	template<> struct BuiltinOptionsTraits<tflite::ReducerOptions> {
1611	static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
1612	};
1613
1614	template<> struct BuiltinOptionsTraits<tflite::SubOptions> {
1615	static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
1616	};
1617
1618	template<> struct BuiltinOptionsTraits<tflite::DivOptions> {
1619	static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
1620	};
1621
1622	template<> struct BuiltinOptionsTraits<tflite::SqueezeOptions> {
1623	static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
1624	};
1625
1626	template<> struct BuiltinOptionsTraits<tflite::SequenceRNNOptions> {
1627	static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
1628	};
1629
1630	template<> struct BuiltinOptionsTraits<tflite::StridedSliceOptions> {
1631	static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
1632	};
1633
1634	template<> struct BuiltinOptionsTraits<tflite::ExpOptions> {
1635	static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
1636	};
1637
1638	template<> struct BuiltinOptionsTraits<tflite::TopKV2Options> {
1639	static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
1640	};
1641
1642	template<> struct BuiltinOptionsTraits<tflite::SplitOptions> {
1643	static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
1644	};
1645
1646	template<> struct BuiltinOptionsTraits<tflite::LogSoftmaxOptions> {
1647	static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
1648	};
1649
1650	template<> struct BuiltinOptionsTraits<tflite::CastOptions> {
1651	static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
1652	};
1653
1654	template<> struct BuiltinOptionsTraits<tflite::DequantizeOptions> {
1655	static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
1656	};
1657
1658	template<> struct BuiltinOptionsTraits<tflite::MaximumMinimumOptions> {
1659	static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
1660	};
1661
1662	template<> struct BuiltinOptionsTraits<tflite::ArgMaxOptions> {
1663	static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
1664	};
1665
1666	template<> struct BuiltinOptionsTraits<tflite::LessOptions> {
1667	static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
1668	};
1669
1670	template<> struct BuiltinOptionsTraits<tflite::NegOptions> {
1671	static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
1672	};
1673
1674	template<> struct BuiltinOptionsTraits<tflite::PadV2Options> {
1675	static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
1676	};
1677
1678	template<> struct BuiltinOptionsTraits<tflite::GreaterOptions> {
1679	static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
1680	};
1681
1682	template<> struct BuiltinOptionsTraits<tflite::GreaterEqualOptions> {
1683	static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
1684	};
1685
1686	template<> struct BuiltinOptionsTraits<tflite::LessEqualOptions> {
1687	static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
1688	};
1689
1690	template<> struct BuiltinOptionsTraits<tflite::SelectOptions> {
1691	static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
1692	};
1693
1694	template<> struct BuiltinOptionsTraits<tflite::SliceOptions> {
1695	static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
1696	};
1697
1698	template<> struct BuiltinOptionsTraits<tflite::TransposeConvOptions> {
1699	static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
1700	};
1701
1702	template<> struct BuiltinOptionsTraits<tflite::SparseToDenseOptions> {
1703	static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
1704	};
1705
1706	template<> struct BuiltinOptionsTraits<tflite::TileOptions> {
1707	static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
1708	};
1709
1710	template<> struct BuiltinOptionsTraits<tflite::ExpandDimsOptions> {
1711	static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
1712	};
1713
1714	template<> struct BuiltinOptionsTraits<tflite::EqualOptions> {
1715	static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
1716	};
1717
1718	template<> struct BuiltinOptionsTraits<tflite::NotEqualOptions> {
1719	static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
1720	};
1721
1722	template<> struct BuiltinOptionsTraits<tflite::ShapeOptions> {
1723	static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
1724	};
1725
1726	template<> struct BuiltinOptionsTraits<tflite::PowOptions> {
1727	static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
1728	};
1729
1730	template<> struct BuiltinOptionsTraits<tflite::ArgMinOptions> {
1731	static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
1732	};
1733
1734	template<> struct BuiltinOptionsTraits<tflite::FakeQuantOptions> {
1735	static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
1736	};
1737
1738	template<> struct BuiltinOptionsTraits<tflite::PackOptions> {
1739	static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
1740	};
1741
1742	template<> struct BuiltinOptionsTraits<tflite::LogicalOrOptions> {
1743	static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
1744	};
1745
1746	template<> struct BuiltinOptionsTraits<tflite::OneHotOptions> {
1747	static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
1748	};
1749
1750	template<> struct BuiltinOptionsTraits<tflite::LogicalAndOptions> {
1751	static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
1752	};
1753
1754	template<> struct BuiltinOptionsTraits<tflite::LogicalNotOptions> {
1755	static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
1756	};
1757
1758	template<> struct BuiltinOptionsTraits<tflite::UnpackOptions> {
1759	static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
1760	};
1761
1762	template<> struct BuiltinOptionsTraits<tflite::FloorDivOptions> {
1763	static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
1764	};
1765
1766	template<> struct BuiltinOptionsTraits<tflite::SquareOptions> {
1767	static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
1768	};
1769
1770	template<> struct BuiltinOptionsTraits<tflite::ZerosLikeOptions> {
1771	static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
1772	};
1773
1774	template<> struct BuiltinOptionsTraits<tflite::FillOptions> {
1775	static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
1776	};
1777
1778	template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceLSTMOptions> {
1779	static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
1780	};
1781
1782	template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceRNNOptions> {
1783	static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
1784	};
1785
1786	template<> struct BuiltinOptionsTraits<tflite::UnidirectionalSequenceLSTMOptions> {
1787	static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
1788	};
1789
1790	template<> struct BuiltinOptionsTraits<tflite::FloorModOptions> {
1791	static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
1792	};
1793
1794	template<> struct BuiltinOptionsTraits<tflite::RangeOptions> {
1795	static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
1796	};
1797
1798	template<> struct BuiltinOptionsTraits<tflite::ResizeNearestNeighborOptions> {
1799	static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
1800	};
1801
1802	template<> struct BuiltinOptionsTraits<tflite::LeakyReluOptions> {
1803	static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
1804	};
1805
1806	template<> struct BuiltinOptionsTraits<tflite::SquaredDifferenceOptions> {
1807	static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
1808	};
1809
1810	template<> struct BuiltinOptionsTraits<tflite::MirrorPadOptions> {
1811	static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
1812	};
1813
1814	template<> struct BuiltinOptionsTraits<tflite::AbsOptions> {
1815	static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
1816	};
1817
1818	template<> struct BuiltinOptionsTraits<tflite::SplitVOptions> {
1819	static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
1820	};
1821
1822	template<> struct BuiltinOptionsTraits<tflite::UniqueOptions> {
1823	static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
1824	};
1825
1826	template<> struct BuiltinOptionsTraits<tflite::ReverseV2Options> {
1827	static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
1828	};
1829
1830	template<> struct BuiltinOptionsTraits<tflite::AddNOptions> {
1831	static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
1832	};
1833
1834	template<> struct BuiltinOptionsTraits<tflite::GatherNdOptions> {
1835	static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
1836	};
1837
1838	template<> struct BuiltinOptionsTraits<tflite::CosOptions> {
1839	static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
1840	};
1841
1842	template<> struct BuiltinOptionsTraits<tflite::WhereOptions> {
1843	static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
1844	};
1845
1846	template<> struct BuiltinOptionsTraits<tflite::RankOptions> {
1847	static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
1848	};
1849
1850	template<> struct BuiltinOptionsTraits<tflite::ReverseSequenceOptions> {
1851	static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
1852	};
1853
1854	template<> struct BuiltinOptionsTraits<tflite::MatrixDiagOptions> {
1855	static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
1856	};
1857
1858	template<> struct BuiltinOptionsTraits<tflite::QuantizeOptions> {
1859	static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
1860	};
1861
1862	template<> struct BuiltinOptionsTraits<tflite::MatrixSetDiagOptions> {
1863	static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
1864	};
1865
1866	template<> struct BuiltinOptionsTraits<tflite::HardSwishOptions> {
1867	static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
1868	};
1869
1870	template<> struct BuiltinOptionsTraits<tflite::IfOptions> {
1871	static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
1872	};
1873
1874	template<> struct BuiltinOptionsTraits<tflite::WhileOptions> {
1875	static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
1876	};
1877
1878	template<> struct BuiltinOptionsTraits<tflite::DepthToSpaceOptions> {
1879	static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
1880	};
1881
1882	template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV4Options> {
1883	static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
1884	};
1885
1886	template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV5Options> {
1887	static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
1888	};
1889
1890	template<> struct BuiltinOptionsTraits<tflite::ScatterNdOptions> {
1891	static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
1892	};
1893
1894	template<> struct BuiltinOptionsTraits<tflite::SelectV2Options> {
1895	static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
1896	};
1897
1898	template<> struct BuiltinOptionsTraits<tflite::DensifyOptions> {
1899	static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
1900	};
1901
1902	template<> struct BuiltinOptionsTraits<tflite::SegmentSumOptions> {
1903	static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
1904	};
1905
1906	template<> struct BuiltinOptionsTraits<tflite::BatchMatMulOptions> {
1907	static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
1908	};
1909
1910	template<> struct BuiltinOptionsTraits<tflite::CumsumOptions> {
1911	static const BuiltinOptions enum_value = BuiltinOptions_CumsumOptions;
1912	};
1913
1914	template<> struct BuiltinOptionsTraits<tflite::CallOnceOptions> {
1915	static const BuiltinOptions enum_value = BuiltinOptions_CallOnceOptions;
1916	};
1917
1918	template<> struct BuiltinOptionsTraits<tflite::BroadcastToOptions> {
1919	static const BuiltinOptions enum_value = BuiltinOptions_BroadcastToOptions;
1920	};
1921
1922	template<> struct BuiltinOptionsTraits<tflite::Rfft2dOptions> {
1923	static const BuiltinOptions enum_value = BuiltinOptions_Rfft2dOptions;
1924	};
1925
1926	template<> struct BuiltinOptionsTraits<tflite::Conv3DOptions> {
1927	static const BuiltinOptions enum_value = BuiltinOptions_Conv3DOptions;
1928	};
1929
1930	template<> struct BuiltinOptionsTraits<tflite::HashtableOptions> {
1931	static const BuiltinOptions enum_value = BuiltinOptions_HashtableOptions;
1932	};
1933
1934	template<> struct BuiltinOptionsTraits<tflite::HashtableFindOptions> {
1935	static const BuiltinOptions enum_value = BuiltinOptions_HashtableFindOptions;
1936	};
1937
1938	template<> struct BuiltinOptionsTraits<tflite::HashtableImportOptions> {
1939	static const BuiltinOptions enum_value = BuiltinOptions_HashtableImportOptions;
1940	};
1941
1942	template<> struct BuiltinOptionsTraits<tflite::HashtableSizeOptions> {
1943	static const BuiltinOptions enum_value = BuiltinOptions_HashtableSizeOptions;
1944	};
1945
1946	struct BuiltinOptionsUnion {
1947	BuiltinOptions type;
1948	void *value;
1949
1950	BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {}
1951	BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
1952	type(BuiltinOptions_NONE), value(nullptr)
1953	{ std::swap(type, u.type); std::swap(value, u.value); }
1954	BuiltinOptionsUnion(const BuiltinOptionsUnion &) FLATBUFFERS_NOEXCEPT;
1955	BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT
1956	{ BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
1957	BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
1958	{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
1959	~BuiltinOptionsUnion() { Reset(); }
1960
1961	void Reset();
1962
1963	#ifndef FLATBUFFERS_CPP98_STL
1964	template <typename T>
1965	void Set(T&& val) {
1966	using RT = typename std::remove_reference<T>::type;
1967	Reset();
1968	type = BuiltinOptionsTraits<typename RT::TableType>::enum_value;
1969	if (type != BuiltinOptions_NONE) {
1970	value = new RT(std::forward<T>(val));
1971	}
1972	}
1973	#endif // FLATBUFFERS_CPP98_STL
1974
1975	static void UnPack(const* void obj, BuiltinOptions type, const* flatbuffers::resolver_function_t *resolver);
1976	flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher = nullptr) const*;
1977
1978	tflite::Conv2DOptionsT *AsConv2DOptions() {
1979	return type == BuiltinOptions_Conv2DOptions ?
1980	reinterpret_cast<tflite::Conv2DOptionsT >(value) : nullptr*;
1981	}
1982	const tflite::Conv2DOptionsT AsConv2DOptions() const* {
1983	return type == BuiltinOptions_Conv2DOptions ?
1984	reinterpret_cast<const tflite::Conv2DOptionsT >(value) : nullptr*;
1985	}
1986	tflite::DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() {
1987	return type == BuiltinOptions_DepthwiseConv2DOptions ?
1988	reinterpret_cast<tflite::DepthwiseConv2DOptionsT >(value) : nullptr*;
1989	}
1990	const tflite::DepthwiseConv2DOptionsT AsDepthwiseConv2DOptions() const* {
1991	return type == BuiltinOptions_DepthwiseConv2DOptions ?
1992	reinterpret_cast<const tflite::DepthwiseConv2DOptionsT >(value) : nullptr*;
1993	}
1994	tflite::ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() {
1995	return type == BuiltinOptions_ConcatEmbeddingsOptions ?
1996	reinterpret_cast<tflite::ConcatEmbeddingsOptionsT >(value) : nullptr*;
1997	}
1998	const tflite::ConcatEmbeddingsOptionsT AsConcatEmbeddingsOptions() const* {
1999	return type == BuiltinOptions_ConcatEmbeddingsOptions ?
2000	reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT >(value) : nullptr*;
2001	}
2002	tflite::LSHProjectionOptionsT *AsLSHProjectionOptions() {
2003	return type == BuiltinOptions_LSHProjectionOptions ?
2004	reinterpret_cast<tflite::LSHProjectionOptionsT >(value) : nullptr*;
2005	}
2006	const tflite::LSHProjectionOptionsT AsLSHProjectionOptions() const* {
2007	return type == BuiltinOptions_LSHProjectionOptions ?
2008	reinterpret_cast<const tflite::LSHProjectionOptionsT >(value) : nullptr*;
2009	}
2010	tflite::Pool2DOptionsT *AsPool2DOptions() {
2011	return type == BuiltinOptions_Pool2DOptions ?
2012	reinterpret_cast<tflite::Pool2DOptionsT >(value) : nullptr*;
2013	}
2014	const tflite::Pool2DOptionsT AsPool2DOptions() const* {
2015	return type == BuiltinOptions_Pool2DOptions ?
2016	reinterpret_cast<const tflite::Pool2DOptionsT >(value) : nullptr*;
2017	}
2018	tflite::SVDFOptionsT *AsSVDFOptions() {
2019	return type == BuiltinOptions_SVDFOptions ?
2020	reinterpret_cast<tflite::SVDFOptionsT >(value) : nullptr*;
2021	}
2022	const tflite::SVDFOptionsT AsSVDFOptions() const* {
2023	return type == BuiltinOptions_SVDFOptions ?
2024	reinterpret_cast<const tflite::SVDFOptionsT >(value) : nullptr*;
2025	}
2026	tflite::RNNOptionsT *AsRNNOptions() {
2027	return type == BuiltinOptions_RNNOptions ?
2028	reinterpret_cast<tflite::RNNOptionsT >(value) : nullptr*;
2029	}
2030	const tflite::RNNOptionsT AsRNNOptions() const* {
2031	return type == BuiltinOptions_RNNOptions ?
2032	reinterpret_cast<const tflite::RNNOptionsT >(value) : nullptr*;
2033	}
2034	tflite::FullyConnectedOptionsT *AsFullyConnectedOptions() {
2035	return type == BuiltinOptions_FullyConnectedOptions ?
2036	reinterpret_cast<tflite::FullyConnectedOptionsT >(value) : nullptr*;
2037	}
2038	const tflite::FullyConnectedOptionsT AsFullyConnectedOptions() const* {
2039	return type == BuiltinOptions_FullyConnectedOptions ?
2040	reinterpret_cast<const tflite::FullyConnectedOptionsT >(value) : nullptr*;
2041	}
2042	tflite::SoftmaxOptionsT *AsSoftmaxOptions() {
2043	return type == BuiltinOptions_SoftmaxOptions ?
2044	reinterpret_cast<tflite::SoftmaxOptionsT >(value) : nullptr*;
2045	}
2046	const tflite::SoftmaxOptionsT AsSoftmaxOptions() const* {
2047	return type == BuiltinOptions_SoftmaxOptions ?
2048	reinterpret_cast<const tflite::SoftmaxOptionsT >(value) : nullptr*;
2049	}
2050	tflite::ConcatenationOptionsT *AsConcatenationOptions() {
2051	return type == BuiltinOptions_ConcatenationOptions ?
2052	reinterpret_cast<tflite::ConcatenationOptionsT >(value) : nullptr*;
2053	}
2054	const tflite::ConcatenationOptionsT AsConcatenationOptions() const* {
2055	return type == BuiltinOptions_ConcatenationOptions ?
2056	reinterpret_cast<const tflite::ConcatenationOptionsT >(value) : nullptr*;
2057	}
2058	tflite::AddOptionsT *AsAddOptions() {
2059	return type == BuiltinOptions_AddOptions ?
2060	reinterpret_cast<tflite::AddOptionsT >(value) : nullptr*;
2061	}
2062	const tflite::AddOptionsT AsAddOptions() const* {
2063	return type == BuiltinOptions_AddOptions ?
2064	reinterpret_cast<const tflite::AddOptionsT >(value) : nullptr*;
2065	}
2066	tflite::L2NormOptionsT *AsL2NormOptions() {
2067	return type == BuiltinOptions_L2NormOptions ?
2068	reinterpret_cast<tflite::L2NormOptionsT >(value) : nullptr*;
2069	}
2070	const tflite::L2NormOptionsT AsL2NormOptions() const* {
2071	return type == BuiltinOptions_L2NormOptions ?
2072	reinterpret_cast<const tflite::L2NormOptionsT >(value) : nullptr*;
2073	}
2074	tflite::LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() {
2075	return type == BuiltinOptions_LocalResponseNormalizationOptions ?
2076	reinterpret_cast<tflite::LocalResponseNormalizationOptionsT >(value) : nullptr*;
2077	}
2078	const tflite::LocalResponseNormalizationOptionsT AsLocalResponseNormalizationOptions() const* {
2079	return type == BuiltinOptions_LocalResponseNormalizationOptions ?
2080	reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT >(value) : nullptr*;
2081	}
2082	tflite::LSTMOptionsT *AsLSTMOptions() {
2083	return type == BuiltinOptions_LSTMOptions ?
2084	reinterpret_cast<tflite::LSTMOptionsT >(value) : nullptr*;
2085	}
2086	const tflite::LSTMOptionsT AsLSTMOptions() const* {
2087	return type == BuiltinOptions_LSTMOptions ?
2088	reinterpret_cast<const tflite::LSTMOptionsT >(value) : nullptr*;
2089	}
2090	tflite::ResizeBilinearOptionsT *AsResizeBilinearOptions() {
2091	return type == BuiltinOptions_ResizeBilinearOptions ?
2092	reinterpret_cast<tflite::ResizeBilinearOptionsT >(value) : nullptr*;
2093	}
2094	const tflite::ResizeBilinearOptionsT AsResizeBilinearOptions() const* {
2095	return type == BuiltinOptions_ResizeBilinearOptions ?
2096	reinterpret_cast<const tflite::ResizeBilinearOptionsT >(value) : nullptr*;
2097	}
2098	tflite::CallOptionsT *AsCallOptions() {
2099	return type == BuiltinOptions_CallOptions ?
2100	reinterpret_cast<tflite::CallOptionsT >(value) : nullptr*;
2101	}
2102	const tflite::CallOptionsT AsCallOptions() const* {
2103	return type == BuiltinOptions_CallOptions ?
2104	reinterpret_cast<const tflite::CallOptionsT >(value) : nullptr*;
2105	}
2106	tflite::ReshapeOptionsT *AsReshapeOptions() {
2107	return type == BuiltinOptions_ReshapeOptions ?
2108	reinterpret_cast<tflite::ReshapeOptionsT >(value) : nullptr*;
2109	}
2110	const tflite::ReshapeOptionsT AsReshapeOptions() const* {
2111	return type == BuiltinOptions_ReshapeOptions ?
2112	reinterpret_cast<const tflite::ReshapeOptionsT >(value) : nullptr*;
2113	}
2114	tflite::SkipGramOptionsT *AsSkipGramOptions() {
2115	return type == BuiltinOptions_SkipGramOptions ?
2116	reinterpret_cast<tflite::SkipGramOptionsT >(value) : nullptr*;
2117	}
2118	const tflite::SkipGramOptionsT AsSkipGramOptions() const* {
2119	return type == BuiltinOptions_SkipGramOptions ?
2120	reinterpret_cast<const tflite::SkipGramOptionsT >(value) : nullptr*;
2121	}
2122	tflite::SpaceToDepthOptionsT *AsSpaceToDepthOptions() {
2123	return type == BuiltinOptions_SpaceToDepthOptions ?
2124	reinterpret_cast<tflite::SpaceToDepthOptionsT >(value) : nullptr*;
2125	}
2126	const tflite::SpaceToDepthOptionsT AsSpaceToDepthOptions() const* {
2127	return type == BuiltinOptions_SpaceToDepthOptions ?
2128	reinterpret_cast<const tflite::SpaceToDepthOptionsT >(value) : nullptr*;
2129	}
2130	tflite::EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() {
2131	return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
2132	reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT >(value) : nullptr*;
2133	}
2134	const tflite::EmbeddingLookupSparseOptionsT AsEmbeddingLookupSparseOptions() const* {
2135	return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
2136	reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT >(value) : nullptr*;
2137	}
2138	tflite::MulOptionsT *AsMulOptions() {
2139	return type == BuiltinOptions_MulOptions ?
2140	reinterpret_cast<tflite::MulOptionsT >(value) : nullptr*;
2141	}
2142	const tflite::MulOptionsT AsMulOptions() const* {
2143	return type == BuiltinOptions_MulOptions ?
2144	reinterpret_cast<const tflite::MulOptionsT >(value) : nullptr*;
2145	}
2146	tflite::PadOptionsT *AsPadOptions() {
2147	return type == BuiltinOptions_PadOptions ?
2148	reinterpret_cast<tflite::PadOptionsT >(value) : nullptr*;
2149	}
2150	const tflite::PadOptionsT AsPadOptions() const* {
2151	return type == BuiltinOptions_PadOptions ?
2152	reinterpret_cast<const tflite::PadOptionsT >(value) : nullptr*;
2153	}
2154	tflite::GatherOptionsT *AsGatherOptions() {
2155	return type == BuiltinOptions_GatherOptions ?
2156	reinterpret_cast<tflite::GatherOptionsT >(value) : nullptr*;
2157	}
2158	const tflite::GatherOptionsT AsGatherOptions() const* {
2159	return type == BuiltinOptions_GatherOptions ?
2160	reinterpret_cast<const tflite::GatherOptionsT >(value) : nullptr*;
2161	}
2162	tflite::BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() {
2163	return type == BuiltinOptions_BatchToSpaceNDOptions ?
2164	reinterpret_cast<tflite::BatchToSpaceNDOptionsT >(value) : nullptr*;
2165	}
2166	const tflite::BatchToSpaceNDOptionsT AsBatchToSpaceNDOptions() const* {
2167	return type == BuiltinOptions_BatchToSpaceNDOptions ?
2168	reinterpret_cast<const tflite::BatchToSpaceNDOptionsT >(value) : nullptr*;
2169	}
2170	tflite::SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() {
2171	return type == BuiltinOptions_SpaceToBatchNDOptions ?
2172	reinterpret_cast<tflite::SpaceToBatchNDOptionsT >(value) : nullptr*;
2173	}
2174	const tflite::SpaceToBatchNDOptionsT AsSpaceToBatchNDOptions() const* {
2175	return type == BuiltinOptions_SpaceToBatchNDOptions ?
2176	reinterpret_cast<const tflite::SpaceToBatchNDOptionsT >(value) : nullptr*;
2177	}
2178	tflite::TransposeOptionsT *AsTransposeOptions() {
2179	return type == BuiltinOptions_TransposeOptions ?
2180	reinterpret_cast<tflite::TransposeOptionsT >(value) : nullptr*;
2181	}
2182	const tflite::TransposeOptionsT AsTransposeOptions() const* {
2183	return type == BuiltinOptions_TransposeOptions ?
2184	reinterpret_cast<const tflite::TransposeOptionsT >(value) : nullptr*;
2185	}
2186	tflite::ReducerOptionsT *AsReducerOptions() {
2187	return type == BuiltinOptions_ReducerOptions ?
2188	reinterpret_cast<tflite::ReducerOptionsT >(value) : nullptr*;
2189	}
2190	const tflite::ReducerOptionsT AsReducerOptions() const* {
2191	return type == BuiltinOptions_ReducerOptions ?
2192	reinterpret_cast<const tflite::ReducerOptionsT >(value) : nullptr*;
2193	}
2194	tflite::SubOptionsT *AsSubOptions() {
2195	return type == BuiltinOptions_SubOptions ?
2196	reinterpret_cast<tflite::SubOptionsT >(value) : nullptr*;
2197	}
2198	const tflite::SubOptionsT AsSubOptions() const* {
2199	return type == BuiltinOptions_SubOptions ?
2200	reinterpret_cast<const tflite::SubOptionsT >(value) : nullptr*;
2201	}
2202	tflite::DivOptionsT *AsDivOptions() {
2203	return type == BuiltinOptions_DivOptions ?
2204	reinterpret_cast<tflite::DivOptionsT >(value) : nullptr*;
2205	}
2206	const tflite::DivOptionsT AsDivOptions() const* {
2207	return type == BuiltinOptions_DivOptions ?
2208	reinterpret_cast<const tflite::DivOptionsT >(value) : nullptr*;
2209	}
2210	tflite::SqueezeOptionsT *AsSqueezeOptions() {
2211	return type == BuiltinOptions_SqueezeOptions ?
2212	reinterpret_cast<tflite::SqueezeOptionsT >(value) : nullptr*;
2213	}
2214	const tflite::SqueezeOptionsT AsSqueezeOptions() const* {
2215	return type == BuiltinOptions_SqueezeOptions ?
2216	reinterpret_cast<const tflite::SqueezeOptionsT >(value) : nullptr*;
2217	}
2218	tflite::SequenceRNNOptionsT *AsSequenceRNNOptions() {
2219	return type == BuiltinOptions_SequenceRNNOptions ?
2220	reinterpret_cast<tflite::SequenceRNNOptionsT >(value) : nullptr*;
2221	}
2222	const tflite::SequenceRNNOptionsT AsSequenceRNNOptions() const* {
2223	return type == BuiltinOptions_SequenceRNNOptions ?
2224	reinterpret_cast<const tflite::SequenceRNNOptionsT >(value) : nullptr*;
2225	}
2226	tflite::StridedSliceOptionsT *AsStridedSliceOptions() {
2227	return type == BuiltinOptions_StridedSliceOptions ?
2228	reinterpret_cast<tflite::StridedSliceOptionsT >(value) : nullptr*;
2229	}
2230	const tflite::StridedSliceOptionsT AsStridedSliceOptions() const* {
2231	return type == BuiltinOptions_StridedSliceOptions ?
2232	reinterpret_cast<const tflite::StridedSliceOptionsT >(value) : nullptr*;
2233	}
2234	tflite::ExpOptionsT *AsExpOptions() {
2235	return type == BuiltinOptions_ExpOptions ?
2236	reinterpret_cast<tflite::ExpOptionsT >(value) : nullptr*;
2237	}
2238	const tflite::ExpOptionsT AsExpOptions() const* {
2239	return type == BuiltinOptions_ExpOptions ?
2240	reinterpret_cast<const tflite::ExpOptionsT >(value) : nullptr*;
2241	}
2242	tflite::TopKV2OptionsT *AsTopKV2Options() {
2243	return type == BuiltinOptions_TopKV2Options ?
2244	reinterpret_cast<tflite::TopKV2OptionsT >(value) : nullptr*;
2245	}
2246	const tflite::TopKV2OptionsT AsTopKV2Options() const* {
2247	return type == BuiltinOptions_TopKV2Options ?
2248	reinterpret_cast<const tflite::TopKV2OptionsT >(value) : nullptr*;
2249	}
2250	tflite::SplitOptionsT *AsSplitOptions() {
2251	return type == BuiltinOptions_SplitOptions ?
2252	reinterpret_cast<tflite::SplitOptionsT >(value) : nullptr*;
2253	}
2254	const tflite::SplitOptionsT AsSplitOptions() const* {
2255	return type == BuiltinOptions_SplitOptions ?
2256	reinterpret_cast<const tflite::SplitOptionsT >(value) : nullptr*;
2257	}
2258	tflite::LogSoftmaxOptionsT *AsLogSoftmaxOptions() {
2259	return type == BuiltinOptions_LogSoftmaxOptions ?
2260	reinterpret_cast<tflite::LogSoftmaxOptionsT >(value) : nullptr*;
2261	}
2262	const tflite::LogSoftmaxOptionsT AsLogSoftmaxOptions() const* {
2263	return type == BuiltinOptions_LogSoftmaxOptions ?
2264	reinterpret_cast<const tflite::LogSoftmaxOptionsT >(value) : nullptr*;
2265	}
2266	tflite::CastOptionsT *AsCastOptions() {
2267	return type == BuiltinOptions_CastOptions ?
2268	reinterpret_cast<tflite::CastOptionsT >(value) : nullptr*;
2269	}
2270	const tflite::CastOptionsT AsCastOptions() const* {
2271	return type == BuiltinOptions_CastOptions ?
2272	reinterpret_cast<const tflite::CastOptionsT >(value) : nullptr*;
2273	}
2274	tflite::DequantizeOptionsT *AsDequantizeOptions() {
2275	return type == BuiltinOptions_DequantizeOptions ?
2276	reinterpret_cast<tflite::DequantizeOptionsT >(value) : nullptr*;
2277	}
2278	const tflite::DequantizeOptionsT AsDequantizeOptions() const* {
2279	return type == BuiltinOptions_DequantizeOptions ?
2280	reinterpret_cast<const tflite::DequantizeOptionsT >(value) : nullptr*;
2281	}
2282	tflite::MaximumMinimumOptionsT *AsMaximumMinimumOptions() {
2283	return type == BuiltinOptions_MaximumMinimumOptions ?
2284	reinterpret_cast<tflite::MaximumMinimumOptionsT >(value) : nullptr*;
2285	}
2286	const tflite::MaximumMinimumOptionsT AsMaximumMinimumOptions() const* {
2287	return type == BuiltinOptions_MaximumMinimumOptions ?
2288	reinterpret_cast<const tflite::MaximumMinimumOptionsT >(value) : nullptr*;
2289	}
2290	tflite::ArgMaxOptionsT *AsArgMaxOptions() {
2291	return type == BuiltinOptions_ArgMaxOptions ?
2292	reinterpret_cast<tflite::ArgMaxOptionsT >(value) : nullptr*;
2293	}
2294	const tflite::ArgMaxOptionsT AsArgMaxOptions() const* {
2295	return type == BuiltinOptions_ArgMaxOptions ?
2296	reinterpret_cast<const tflite::ArgMaxOptionsT >(value) : nullptr*;
2297	}
2298	tflite::LessOptionsT *AsLessOptions() {
2299	return type == BuiltinOptions_LessOptions ?
2300	reinterpret_cast<tflite::LessOptionsT >(value) : nullptr*;
2301	}
2302	const tflite::LessOptionsT AsLessOptions() const* {
2303	return type == BuiltinOptions_LessOptions ?
2304	reinterpret_cast<const tflite::LessOptionsT >(value) : nullptr*;
2305	}
2306	tflite::NegOptionsT *AsNegOptions() {
2307	return type == BuiltinOptions_NegOptions ?
2308	reinterpret_cast<tflite::NegOptionsT >(value) : nullptr*;
2309	}
2310	const tflite::NegOptionsT AsNegOptions() const* {
2311	return type == BuiltinOptions_NegOptions ?
2312	reinterpret_cast<const tflite::NegOptionsT >(value) : nullptr*;
2313	}
2314	tflite::PadV2OptionsT *AsPadV2Options() {
2315	return type == BuiltinOptions_PadV2Options ?
2316	reinterpret_cast<tflite::PadV2OptionsT >(value) : nullptr*;
2317	}
2318	const tflite::PadV2OptionsT AsPadV2Options() const* {
2319	return type == BuiltinOptions_PadV2Options ?
2320	reinterpret_cast<const tflite::PadV2OptionsT >(value) : nullptr*;
2321	}
2322	tflite::GreaterOptionsT *AsGreaterOptions() {
2323	return type == BuiltinOptions_GreaterOptions ?
2324	reinterpret_cast<tflite::GreaterOptionsT >(value) : nullptr*;
2325	}
2326	const tflite::GreaterOptionsT AsGreaterOptions() const* {
2327	return type == BuiltinOptions_GreaterOptions ?
2328	reinterpret_cast<const tflite::GreaterOptionsT >(value) : nullptr*;
2329	}
2330	tflite::GreaterEqualOptionsT *AsGreaterEqualOptions() {
2331	return type == BuiltinOptions_GreaterEqualOptions ?
2332	reinterpret_cast<tflite::GreaterEqualOptionsT >(value) : nullptr*;
2333	}
2334	const tflite::GreaterEqualOptionsT AsGreaterEqualOptions() const* {
2335	return type == BuiltinOptions_GreaterEqualOptions ?
2336	reinterpret_cast<const tflite::GreaterEqualOptionsT >(value) : nullptr*;
2337	}
2338	tflite::LessEqualOptionsT *AsLessEqualOptions() {
2339	return type == BuiltinOptions_LessEqualOptions ?
2340	reinterpret_cast<tflite::LessEqualOptionsT >(value) : nullptr*;
2341	}
2342	const tflite::LessEqualOptionsT AsLessEqualOptions() const* {
2343	return type == BuiltinOptions_LessEqualOptions ?
2344	reinterpret_cast<const tflite::LessEqualOptionsT >(value) : nullptr*;
2345	}
2346	tflite::SelectOptionsT *AsSelectOptions() {
2347	return type == BuiltinOptions_SelectOptions ?
2348	reinterpret_cast<tflite::SelectOptionsT >(value) : nullptr*;
2349	}
2350	const tflite::SelectOptionsT AsSelectOptions() const* {
2351	return type == BuiltinOptions_SelectOptions ?
2352	reinterpret_cast<const tflite::SelectOptionsT >(value) : nullptr*;
2353	}
2354	tflite::SliceOptionsT *AsSliceOptions() {
2355	return type == BuiltinOptions_SliceOptions ?
2356	reinterpret_cast<tflite::SliceOptionsT >(value) : nullptr*;
2357	}
2358	const tflite::SliceOptionsT AsSliceOptions() const* {
2359	return type == BuiltinOptions_SliceOptions ?
2360	reinterpret_cast<const tflite::SliceOptionsT >(value) : nullptr*;
2361	}
2362	tflite::TransposeConvOptionsT *AsTransposeConvOptions() {
2363	return type == BuiltinOptions_TransposeConvOptions ?
2364	reinterpret_cast<tflite::TransposeConvOptionsT >(value) : nullptr*;
2365	}
2366	const tflite::TransposeConvOptionsT AsTransposeConvOptions() const* {
2367	return type == BuiltinOptions_TransposeConvOptions ?
2368	reinterpret_cast<const tflite::TransposeConvOptionsT >(value) : nullptr*;
2369	}
2370	tflite::SparseToDenseOptionsT *AsSparseToDenseOptions() {
2371	return type == BuiltinOptions_SparseToDenseOptions ?
2372	reinterpret_cast<tflite::SparseToDenseOptionsT >(value) : nullptr*;
2373	}
2374	const tflite::SparseToDenseOptionsT AsSparseToDenseOptions() const* {
2375	return type == BuiltinOptions_SparseToDenseOptions ?
2376	reinterpret_cast<const tflite::SparseToDenseOptionsT >(value) : nullptr*;
2377	}
2378	tflite::TileOptionsT *AsTileOptions() {
2379	return type == BuiltinOptions_TileOptions ?
2380	reinterpret_cast<tflite::TileOptionsT >(value) : nullptr*;
2381	}
2382	const tflite::TileOptionsT AsTileOptions() const* {
2383	return type == BuiltinOptions_TileOptions ?
2384	reinterpret_cast<const tflite::TileOptionsT >(value) : nullptr*;
2385	}
2386	tflite::ExpandDimsOptionsT *AsExpandDimsOptions() {
2387	return type == BuiltinOptions_ExpandDimsOptions ?
2388	reinterpret_cast<tflite::ExpandDimsOptionsT >(value) : nullptr*;
2389	}
2390	const tflite::ExpandDimsOptionsT AsExpandDimsOptions() const* {
2391	return type == BuiltinOptions_ExpandDimsOptions ?
2392	reinterpret_cast<const tflite::ExpandDimsOptionsT >(value) : nullptr*;
2393	}
2394	tflite::EqualOptionsT *AsEqualOptions() {
2395	return type == BuiltinOptions_EqualOptions ?
2396	reinterpret_cast<tflite::EqualOptionsT >(value) : nullptr*;
2397	}
2398	const tflite::EqualOptionsT AsEqualOptions() const* {
2399	return type == BuiltinOptions_EqualOptions ?
2400	reinterpret_cast<const tflite::EqualOptionsT >(value) : nullptr*;
2401	}
2402	tflite::NotEqualOptionsT *AsNotEqualOptions() {
2403	return type == BuiltinOptions_NotEqualOptions ?
2404	reinterpret_cast<tflite::NotEqualOptionsT >(value) : nullptr*;
2405	}
2406	const tflite::NotEqualOptionsT AsNotEqualOptions() const* {
2407	return type == BuiltinOptions_NotEqualOptions ?
2408	reinterpret_cast<const tflite::NotEqualOptionsT >(value) : nullptr*;
2409	}
2410	tflite::ShapeOptionsT *AsShapeOptions() {
2411	return type == BuiltinOptions_ShapeOptions ?
2412	reinterpret_cast<tflite::ShapeOptionsT >(value) : nullptr*;
2413	}
2414	const tflite::ShapeOptionsT AsShapeOptions() const* {
2415	return type == BuiltinOptions_ShapeOptions ?
2416	reinterpret_cast<const tflite::ShapeOptionsT >(value) : nullptr*;
2417	}
2418	tflite::PowOptionsT *AsPowOptions() {
2419	return type == BuiltinOptions_PowOptions ?
2420	reinterpret_cast<tflite::PowOptionsT >(value) : nullptr*;
2421	}
2422	const tflite::PowOptionsT AsPowOptions() const* {
2423	return type == BuiltinOptions_PowOptions ?
2424	reinterpret_cast<const tflite::PowOptionsT >(value) : nullptr*;
2425	}
2426	tflite::ArgMinOptionsT *AsArgMinOptions() {
2427	return type == BuiltinOptions_ArgMinOptions ?
2428	reinterpret_cast<tflite::ArgMinOptionsT >(value) : nullptr*;
2429	}
2430	const tflite::ArgMinOptionsT AsArgMinOptions() const* {
2431	return type == BuiltinOptions_ArgMinOptions ?
2432	reinterpret_cast<const tflite::ArgMinOptionsT >(value) : nullptr*;
2433	}
2434	tflite::FakeQuantOptionsT *AsFakeQuantOptions() {
2435	return type == BuiltinOptions_FakeQuantOptions ?
2436	reinterpret_cast<tflite::FakeQuantOptionsT >(value) : nullptr*;
2437	}
2438	const tflite::FakeQuantOptionsT AsFakeQuantOptions() const* {
2439	return type == BuiltinOptions_FakeQuantOptions ?
2440	reinterpret_cast<const tflite::FakeQuantOptionsT >(value) : nullptr*;
2441	}
2442	tflite::PackOptionsT *AsPackOptions() {
2443	return type == BuiltinOptions_PackOptions ?
2444	reinterpret_cast<tflite::PackOptionsT >(value) : nullptr*;
2445	}
2446	const tflite::PackOptionsT AsPackOptions() const* {
2447	return type == BuiltinOptions_PackOptions ?
2448	reinterpret_cast<const tflite::PackOptionsT >(value) : nullptr*;
2449	}
2450	tflite::LogicalOrOptionsT *AsLogicalOrOptions() {
2451	return type == BuiltinOptions_LogicalOrOptions ?
2452	reinterpret_cast<tflite::LogicalOrOptionsT >(value) : nullptr*;
2453	}
2454	const tflite::LogicalOrOptionsT AsLogicalOrOptions() const* {
2455	return type == BuiltinOptions_LogicalOrOptions ?
2456	reinterpret_cast<const tflite::LogicalOrOptionsT >(value) : nullptr*;
2457	}
2458	tflite::OneHotOptionsT *AsOneHotOptions() {
2459	return type == BuiltinOptions_OneHotOptions ?
2460	reinterpret_cast<tflite::OneHotOptionsT >(value) : nullptr*;
2461	}
2462	const tflite::OneHotOptionsT AsOneHotOptions() const* {
2463	return type == BuiltinOptions_OneHotOptions ?
2464	reinterpret_cast<const tflite::OneHotOptionsT >(value) : nullptr*;
2465	}
2466	tflite::LogicalAndOptionsT *AsLogicalAndOptions() {
2467	return type == BuiltinOptions_LogicalAndOptions ?
2468	reinterpret_cast<tflite::LogicalAndOptionsT >(value) : nullptr*;
2469	}
2470	const tflite::LogicalAndOptionsT AsLogicalAndOptions() const* {
2471	return type == BuiltinOptions_LogicalAndOptions ?
2472	reinterpret_cast<const tflite::LogicalAndOptionsT >(value) : nullptr*;
2473	}
2474	tflite::LogicalNotOptionsT *AsLogicalNotOptions() {
2475	return type == BuiltinOptions_LogicalNotOptions ?
2476	reinterpret_cast<tflite::LogicalNotOptionsT >(value) : nullptr*;
2477	}
2478	const tflite::LogicalNotOptionsT AsLogicalNotOptions() const* {
2479	return type == BuiltinOptions_LogicalNotOptions ?
2480	reinterpret_cast<const tflite::LogicalNotOptionsT >(value) : nullptr*;
2481	}
2482	tflite::UnpackOptionsT *AsUnpackOptions() {
2483	return type == BuiltinOptions_UnpackOptions ?
2484	reinterpret_cast<tflite::UnpackOptionsT >(value) : nullptr*;
2485	}
2486	const tflite::UnpackOptionsT AsUnpackOptions() const* {
2487	return type == BuiltinOptions_UnpackOptions ?
2488	reinterpret_cast<const tflite::UnpackOptionsT >(value) : nullptr*;
2489	}
2490	tflite::FloorDivOptionsT *AsFloorDivOptions() {
2491	return type == BuiltinOptions_FloorDivOptions ?
2492	reinterpret_cast<tflite::FloorDivOptionsT >(value) : nullptr*;
2493	}
2494	const tflite::FloorDivOptionsT AsFloorDivOptions() const* {
2495	return type == BuiltinOptions_FloorDivOptions ?
2496	reinterpret_cast<const tflite::FloorDivOptionsT >(value) : nullptr*;
2497	}
2498	tflite::SquareOptionsT *AsSquareOptions() {
2499	return type == BuiltinOptions_SquareOptions ?
2500	reinterpret_cast<tflite::SquareOptionsT >(value) : nullptr*;
2501	}
2502	const tflite::SquareOptionsT AsSquareOptions() const* {
2503	return type == BuiltinOptions_SquareOptions ?
2504	reinterpret_cast<const tflite::SquareOptionsT >(value) : nullptr*;
2505	}
2506	tflite::ZerosLikeOptionsT *AsZerosLikeOptions() {
2507	return type == BuiltinOptions_ZerosLikeOptions ?
2508	reinterpret_cast<tflite::ZerosLikeOptionsT >(value) : nullptr*;
2509	}
2510	const tflite::ZerosLikeOptionsT AsZerosLikeOptions() const* {
2511	return type == BuiltinOptions_ZerosLikeOptions ?
2512	reinterpret_cast<const tflite::ZerosLikeOptionsT >(value) : nullptr*;
2513	}
2514	tflite::FillOptionsT *AsFillOptions() {
2515	return type == BuiltinOptions_FillOptions ?
2516	reinterpret_cast<tflite::FillOptionsT >(value) : nullptr*;
2517	}
2518	const tflite::FillOptionsT AsFillOptions() const* {
2519	return type == BuiltinOptions_FillOptions ?
2520	reinterpret_cast<const tflite::FillOptionsT >(value) : nullptr*;
2521	}
2522	tflite::BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() {
2523	return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
2524	reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
2525	}
2526	const tflite::BidirectionalSequenceLSTMOptionsT AsBidirectionalSequenceLSTMOptions() const* {
2527	return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
2528	reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
2529	}
2530	tflite::BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() {
2531	return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
2532	reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT >(value) : nullptr*;
2533	}
2534	const tflite::BidirectionalSequenceRNNOptionsT AsBidirectionalSequenceRNNOptions() const* {
2535	return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
2536	reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT >(value) : nullptr*;
2537	}
2538	tflite::UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() {
2539	return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
2540	reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
2541	}
2542	const tflite::UnidirectionalSequenceLSTMOptionsT AsUnidirectionalSequenceLSTMOptions() const* {
2543	return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
2544	reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
2545	}
2546	tflite::FloorModOptionsT *AsFloorModOptions() {
2547	return type == BuiltinOptions_FloorModOptions ?
2548	reinterpret_cast<tflite::FloorModOptionsT >(value) : nullptr*;
2549	}
2550	const tflite::FloorModOptionsT AsFloorModOptions() const* {
2551	return type == BuiltinOptions_FloorModOptions ?
2552	reinterpret_cast<const tflite::FloorModOptionsT >(value) : nullptr*;
2553	}
2554	tflite::RangeOptionsT *AsRangeOptions() {
2555	return type == BuiltinOptions_RangeOptions ?
2556	reinterpret_cast<tflite::RangeOptionsT >(value) : nullptr*;
2557	}
2558	const tflite::RangeOptionsT AsRangeOptions() const* {
2559	return type == BuiltinOptions_RangeOptions ?
2560	reinterpret_cast<const tflite::RangeOptionsT >(value) : nullptr*;
2561	}
2562	tflite::ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() {
2563	return type == BuiltinOptions_ResizeNearestNeighborOptions ?
2564	reinterpret_cast<tflite::ResizeNearestNeighborOptionsT >(value) : nullptr*;
2565	}
2566	const tflite::ResizeNearestNeighborOptionsT AsResizeNearestNeighborOptions() const* {
2567	return type == BuiltinOptions_ResizeNearestNeighborOptions ?
2568	reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT >(value) : nullptr*;
2569	}
2570	tflite::LeakyReluOptionsT *AsLeakyReluOptions() {
2571	return type == BuiltinOptions_LeakyReluOptions ?
2572	reinterpret_cast<tflite::LeakyReluOptionsT >(value) : nullptr*;
2573	}
2574	const tflite::LeakyReluOptionsT AsLeakyReluOptions() const* {
2575	return type == BuiltinOptions_LeakyReluOptions ?
2576	reinterpret_cast<const tflite::LeakyReluOptionsT >(value) : nullptr*;
2577	}
2578	tflite::SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() {
2579	return type == BuiltinOptions_SquaredDifferenceOptions ?
2580	reinterpret_cast<tflite::SquaredDifferenceOptionsT >(value) : nullptr*;
2581	}
2582	const tflite::SquaredDifferenceOptionsT AsSquaredDifferenceOptions() const* {
2583	return type == BuiltinOptions_SquaredDifferenceOptions ?
2584	reinterpret_cast<const tflite::SquaredDifferenceOptionsT >(value) : nullptr*;
2585	}
2586	tflite::MirrorPadOptionsT *AsMirrorPadOptions() {
2587	return type == BuiltinOptions_MirrorPadOptions ?
2588	reinterpret_cast<tflite::MirrorPadOptionsT >(value) : nullptr*;
2589	}
2590	const tflite::MirrorPadOptionsT AsMirrorPadOptions() const* {
2591	return type == BuiltinOptions_MirrorPadOptions ?
2592	reinterpret_cast<const tflite::MirrorPadOptionsT >(value) : nullptr*;
2593	}
2594	tflite::AbsOptionsT *AsAbsOptions() {
2595	return type == BuiltinOptions_AbsOptions ?
2596	reinterpret_cast<tflite::AbsOptionsT >(value) : nullptr*;
2597	}
2598	const tflite::AbsOptionsT AsAbsOptions() const* {
2599	return type == BuiltinOptions_AbsOptions ?
2600	reinterpret_cast<const tflite::AbsOptionsT >(value) : nullptr*;
2601	}
2602	tflite::SplitVOptionsT *AsSplitVOptions() {
2603	return type == BuiltinOptions_SplitVOptions ?
2604	reinterpret_cast<tflite::SplitVOptionsT >(value) : nullptr*;
2605	}
2606	const tflite::SplitVOptionsT AsSplitVOptions() const* {
2607	return type == BuiltinOptions_SplitVOptions ?
2608	reinterpret_cast<const tflite::SplitVOptionsT >(value) : nullptr*;
2609	}
2610	tflite::UniqueOptionsT *AsUniqueOptions() {
2611	return type == BuiltinOptions_UniqueOptions ?
2612	reinterpret_cast<tflite::UniqueOptionsT >(value) : nullptr*;
2613	}
2614	const tflite::UniqueOptionsT AsUniqueOptions() const* {
2615	return type == BuiltinOptions_UniqueOptions ?
2616	reinterpret_cast<const tflite::UniqueOptionsT >(value) : nullptr*;
2617	}
2618	tflite::ReverseV2OptionsT *AsReverseV2Options() {
2619	return type == BuiltinOptions_ReverseV2Options ?
2620	reinterpret_cast<tflite::ReverseV2OptionsT >(value) : nullptr*;
2621	}
2622	const tflite::ReverseV2OptionsT AsReverseV2Options() const* {
2623	return type == BuiltinOptions_ReverseV2Options ?
2624	reinterpret_cast<const tflite::ReverseV2OptionsT >(value) : nullptr*;
2625	}
2626	tflite::AddNOptionsT *AsAddNOptions() {
2627	return type == BuiltinOptions_AddNOptions ?
2628	reinterpret_cast<tflite::AddNOptionsT >(value) : nullptr*;
2629	}
2630	const tflite::AddNOptionsT AsAddNOptions() const* {
2631	return type == BuiltinOptions_AddNOptions ?
2632	reinterpret_cast<const tflite::AddNOptionsT >(value) : nullptr*;
2633	}
2634	tflite::GatherNdOptionsT *AsGatherNdOptions() {
2635	return type == BuiltinOptions_GatherNdOptions ?
2636	reinterpret_cast<tflite::GatherNdOptionsT >(value) : nullptr*;
2637	}
2638	const tflite::GatherNdOptionsT AsGatherNdOptions() const* {
2639	return type == BuiltinOptions_GatherNdOptions ?
2640	reinterpret_cast<const tflite::GatherNdOptionsT >(value) : nullptr*;
2641	}
2642	tflite::CosOptionsT *AsCosOptions() {
2643	return type == BuiltinOptions_CosOptions ?
2644	reinterpret_cast<tflite::CosOptionsT >(value) : nullptr*;
2645	}
2646	const tflite::CosOptionsT AsCosOptions() const* {
2647	return type == BuiltinOptions_CosOptions ?
2648	reinterpret_cast<const tflite::CosOptionsT >(value) : nullptr*;
2649	}
2650	tflite::WhereOptionsT *AsWhereOptions() {
2651	return type == BuiltinOptions_WhereOptions ?
2652	reinterpret_cast<tflite::WhereOptionsT >(value) : nullptr*;
2653	}
2654	const tflite::WhereOptionsT AsWhereOptions() const* {
2655	return type == BuiltinOptions_WhereOptions ?
2656	reinterpret_cast<const tflite::WhereOptionsT >(value) : nullptr*;
2657	}
2658	tflite::RankOptionsT *AsRankOptions() {
2659	return type == BuiltinOptions_RankOptions ?
2660	reinterpret_cast<tflite::RankOptionsT >(value) : nullptr*;
2661	}
2662	const tflite::RankOptionsT AsRankOptions() const* {
2663	return type == BuiltinOptions_RankOptions ?
2664	reinterpret_cast<const tflite::RankOptionsT >(value) : nullptr*;
2665	}
2666	tflite::ReverseSequenceOptionsT *AsReverseSequenceOptions() {
2667	return type == BuiltinOptions_ReverseSequenceOptions ?
2668	reinterpret_cast<tflite::ReverseSequenceOptionsT >(value) : nullptr*;
2669	}
2670	const tflite::ReverseSequenceOptionsT AsReverseSequenceOptions() const* {
2671	return type == BuiltinOptions_ReverseSequenceOptions ?
2672	reinterpret_cast<const tflite::ReverseSequenceOptionsT >(value) : nullptr*;
2673	}
2674	tflite::MatrixDiagOptionsT *AsMatrixDiagOptions() {
2675	return type == BuiltinOptions_MatrixDiagOptions ?
2676	reinterpret_cast<tflite::MatrixDiagOptionsT >(value) : nullptr*;
2677	}
2678	const tflite::MatrixDiagOptionsT AsMatrixDiagOptions() const* {
2679	return type == BuiltinOptions_MatrixDiagOptions ?
2680	reinterpret_cast<const tflite::MatrixDiagOptionsT >(value) : nullptr*;
2681	}
2682	tflite::QuantizeOptionsT *AsQuantizeOptions() {
2683	return type == BuiltinOptions_QuantizeOptions ?
2684	reinterpret_cast<tflite::QuantizeOptionsT >(value) : nullptr*;
2685	}
2686	const tflite::QuantizeOptionsT AsQuantizeOptions() const* {
2687	return type == BuiltinOptions_QuantizeOptions ?
2688	reinterpret_cast<const tflite::QuantizeOptionsT >(value) : nullptr*;
2689	}
2690	tflite::MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() {
2691	return type == BuiltinOptions_MatrixSetDiagOptions ?
2692	reinterpret_cast<tflite::MatrixSetDiagOptionsT >(value) : nullptr*;
2693	}
2694	const tflite::MatrixSetDiagOptionsT AsMatrixSetDiagOptions() const* {
2695	return type == BuiltinOptions_MatrixSetDiagOptions ?
2696	reinterpret_cast<const tflite::MatrixSetDiagOptionsT >(value) : nullptr*;
2697	}
2698	tflite::HardSwishOptionsT *AsHardSwishOptions() {
2699	return type == BuiltinOptions_HardSwishOptions ?
2700	reinterpret_cast<tflite::HardSwishOptionsT >(value) : nullptr*;
2701	}
2702	const tflite::HardSwishOptionsT AsHardSwishOptions() const* {
2703	return type == BuiltinOptions_HardSwishOptions ?
2704	reinterpret_cast<const tflite::HardSwishOptionsT >(value) : nullptr*;
2705	}
2706	tflite::IfOptionsT *AsIfOptions() {
2707	return type == BuiltinOptions_IfOptions ?
2708	reinterpret_cast<tflite::IfOptionsT >(value) : nullptr*;
2709	}
2710	const tflite::IfOptionsT AsIfOptions() const* {
2711	return type == BuiltinOptions_IfOptions ?
2712	reinterpret_cast<const tflite::IfOptionsT >(value) : nullptr*;
2713	}
2714	tflite::WhileOptionsT *AsWhileOptions() {
2715	return type == BuiltinOptions_WhileOptions ?
2716	reinterpret_cast<tflite::WhileOptionsT >(value) : nullptr*;
2717	}
2718	const tflite::WhileOptionsT AsWhileOptions() const* {
2719	return type == BuiltinOptions_WhileOptions ?
2720	reinterpret_cast<const tflite::WhileOptionsT >(value) : nullptr*;
2721	}
2722	tflite::DepthToSpaceOptionsT *AsDepthToSpaceOptions() {
2723	return type == BuiltinOptions_DepthToSpaceOptions ?
2724	reinterpret_cast<tflite::DepthToSpaceOptionsT >(value) : nullptr*;
2725	}
2726	const tflite::DepthToSpaceOptionsT AsDepthToSpaceOptions() const* {
2727	return type == BuiltinOptions_DepthToSpaceOptions ?
2728	reinterpret_cast<const tflite::DepthToSpaceOptionsT >(value) : nullptr*;
2729	}
2730	tflite::NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() {
2731	return type == BuiltinOptions_NonMaxSuppressionV4Options ?
2732	reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT >(value) : nullptr*;
2733	}
2734	const tflite::NonMaxSuppressionV4OptionsT AsNonMaxSuppressionV4Options() const* {
2735	return type == BuiltinOptions_NonMaxSuppressionV4Options ?
2736	reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT >(value) : nullptr*;
2737	}
2738	tflite::NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() {
2739	return type == BuiltinOptions_NonMaxSuppressionV5Options ?
2740	reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT >(value) : nullptr*;
2741	}
2742	const tflite::NonMaxSuppressionV5OptionsT AsNonMaxSuppressionV5Options() const* {
2743	return type == BuiltinOptions_NonMaxSuppressionV5Options ?
2744	reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT >(value) : nullptr*;
2745	}
2746	tflite::ScatterNdOptionsT *AsScatterNdOptions() {
2747	return type == BuiltinOptions_ScatterNdOptions ?
2748	reinterpret_cast<tflite::ScatterNdOptionsT >(value) : nullptr*;
2749	}
2750	const tflite::ScatterNdOptionsT AsScatterNdOptions() const* {
2751	return type == BuiltinOptions_ScatterNdOptions ?
2752	reinterpret_cast<const tflite::ScatterNdOptionsT >(value) : nullptr*;
2753	}
2754	tflite::SelectV2OptionsT *AsSelectV2Options() {
2755	return type == BuiltinOptions_SelectV2Options ?
2756	reinterpret_cast<tflite::SelectV2OptionsT >(value) : nullptr*;
2757	}
2758	const tflite::SelectV2OptionsT AsSelectV2Options() const* {
2759	return type == BuiltinOptions_SelectV2Options ?
2760	reinterpret_cast<const tflite::SelectV2OptionsT >(value) : nullptr*;
2761	}
2762	tflite::DensifyOptionsT *AsDensifyOptions() {
2763	return type == BuiltinOptions_DensifyOptions ?
2764	reinterpret_cast<tflite::DensifyOptionsT >(value) : nullptr*;
2765	}
2766	const tflite::DensifyOptionsT AsDensifyOptions() const* {
2767	return type == BuiltinOptions_DensifyOptions ?
2768	reinterpret_cast<const tflite::DensifyOptionsT >(value) : nullptr*;
2769	}
2770	tflite::SegmentSumOptionsT *AsSegmentSumOptions() {
2771	return type == BuiltinOptions_SegmentSumOptions ?
2772	reinterpret_cast<tflite::SegmentSumOptionsT >(value) : nullptr*;
2773	}
2774	const tflite::SegmentSumOptionsT AsSegmentSumOptions() const* {
2775	return type == BuiltinOptions_SegmentSumOptions ?
2776	reinterpret_cast<const tflite::SegmentSumOptionsT >(value) : nullptr*;
2777	}
2778	tflite::BatchMatMulOptionsT *AsBatchMatMulOptions() {
2779	return type == BuiltinOptions_BatchMatMulOptions ?
2780	reinterpret_cast<tflite::BatchMatMulOptionsT >(value) : nullptr*;
2781	}
2782	const tflite::BatchMatMulOptionsT AsBatchMatMulOptions() const* {
2783	return type == BuiltinOptions_BatchMatMulOptions ?
2784	reinterpret_cast<const tflite::BatchMatMulOptionsT >(value) : nullptr*;
2785	}
2786	tflite::CumsumOptionsT *AsCumsumOptions() {
2787	return type == BuiltinOptions_CumsumOptions ?
2788	reinterpret_cast<tflite::CumsumOptionsT >(value) : nullptr*;
2789	}
2790	const tflite::CumsumOptionsT AsCumsumOptions() const* {
2791	return type == BuiltinOptions_CumsumOptions ?
2792	reinterpret_cast<const tflite::CumsumOptionsT >(value) : nullptr*;
2793	}
2794	tflite::CallOnceOptionsT *AsCallOnceOptions() {
2795	return type == BuiltinOptions_CallOnceOptions ?
2796	reinterpret_cast<tflite::CallOnceOptionsT >(value) : nullptr*;
2797	}
2798	const tflite::CallOnceOptionsT AsCallOnceOptions() const* {
2799	return type == BuiltinOptions_CallOnceOptions ?
2800	reinterpret_cast<const tflite::CallOnceOptionsT >(value) : nullptr*;
2801	}
2802	tflite::BroadcastToOptionsT *AsBroadcastToOptions() {
2803	return type == BuiltinOptions_BroadcastToOptions ?
2804	reinterpret_cast<tflite::BroadcastToOptionsT >(value) : nullptr*;
2805	}
2806	const tflite::BroadcastToOptionsT AsBroadcastToOptions() const* {
2807	return type == BuiltinOptions_BroadcastToOptions ?
2808	reinterpret_cast<const tflite::BroadcastToOptionsT >(value) : nullptr*;
2809	}
2810	tflite::Rfft2dOptionsT *AsRfft2dOptions() {
2811	return type == BuiltinOptions_Rfft2dOptions ?
2812	reinterpret_cast<tflite::Rfft2dOptionsT >(value) : nullptr*;
2813	}
2814	const tflite::Rfft2dOptionsT AsRfft2dOptions() const* {
2815	return type == BuiltinOptions_Rfft2dOptions ?
2816	reinterpret_cast<const tflite::Rfft2dOptionsT >(value) : nullptr*;
2817	}
2818	tflite::Conv3DOptionsT *AsConv3DOptions() {
2819	return type == BuiltinOptions_Conv3DOptions ?
2820	reinterpret_cast<tflite::Conv3DOptionsT >(value) : nullptr*;
2821	}
2822	const tflite::Conv3DOptionsT AsConv3DOptions() const* {
2823	return type == BuiltinOptions_Conv3DOptions ?
2824	reinterpret_cast<const tflite::Conv3DOptionsT >(value) : nullptr*;
2825	}
2826	tflite::HashtableOptionsT *AsHashtableOptions() {
2827	return type == BuiltinOptions_HashtableOptions ?
2828	reinterpret_cast<tflite::HashtableOptionsT >(value) : nullptr*;
2829	}
2830	const tflite::HashtableOptionsT AsHashtableOptions() const* {
2831	return type == BuiltinOptions_HashtableOptions ?
2832	reinterpret_cast<const tflite::HashtableOptionsT >(value) : nullptr*;
2833	}
2834	tflite::HashtableFindOptionsT *AsHashtableFindOptions() {
2835	return type == BuiltinOptions_HashtableFindOptions ?
2836	reinterpret_cast<tflite::HashtableFindOptionsT >(value) : nullptr*;
2837	}
2838	const tflite::HashtableFindOptionsT AsHashtableFindOptions() const* {
2839	return type == BuiltinOptions_HashtableFindOptions ?
2840	reinterpret_cast<const tflite::HashtableFindOptionsT >(value) : nullptr*;
2841	}
2842	tflite::HashtableImportOptionsT *AsHashtableImportOptions() {
2843	return type == BuiltinOptions_HashtableImportOptions ?
2844	reinterpret_cast<tflite::HashtableImportOptionsT >(value) : nullptr*;
2845	}
2846	const tflite::HashtableImportOptionsT AsHashtableImportOptions() const* {
2847	return type == BuiltinOptions_HashtableImportOptions ?
2848	reinterpret_cast<const tflite::HashtableImportOptionsT >(value) : nullptr*;
2849	}
2850	tflite::HashtableSizeOptionsT *AsHashtableSizeOptions() {
2851	return type == BuiltinOptions_HashtableSizeOptions ?
2852	reinterpret_cast<tflite::HashtableSizeOptionsT >(value) : nullptr*;
2853	}
2854	const tflite::HashtableSizeOptionsT AsHashtableSizeOptions() const* {
2855	return type == BuiltinOptions_HashtableSizeOptions ?
2856	reinterpret_cast<const tflite::HashtableSizeOptionsT >(value) : nullptr*;
2857	}
2858	};
2859
2860	bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
2861	bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types);
2862
2863	enum Padding {
2864	Padding_SAME = `0`,
2865	Padding_VALID = `1`,
2866	Padding_MIN = Padding_SAME,
2867	Padding_MAX = Padding_VALID
2868	};
2869
2870	inline const Padding (&EnumValuesPadding())[`2`] {
2871	static const Padding values[] = {
2872	Padding_SAME,
2873	Padding_VALID
2874	};
2875	return values;
2876	}
2877
2878	inline const char * const *EnumNamesPadding() {
2879	static const char * const names[`3`] = {
2880	"SAME",
2881	"VALID",
2882	nullptr
2883	};
2884	return names;
2885	}
2886
2887	inline const char *EnumNamePadding(Padding e) {
2888	if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID)) return "";
2889	const size_t index = static_cast<size_t>(e);
2890	return EnumNamesPadding()[index];
2891	}
2892
2893	enum ActivationFunctionType {
2894	ActivationFunctionType_NONE = `0`,
2895	ActivationFunctionType_RELU = `1`,
2896	ActivationFunctionType_RELU_N1_TO_1 = `2`,
2897	ActivationFunctionType_RELU6 = `3`,
2898	ActivationFunctionType_TANH = `4`,
2899	ActivationFunctionType_SIGN_BIT = `5`,
2900	ActivationFunctionType_MIN = ActivationFunctionType_NONE,
2901	ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
2902	};
2903
2904	inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[`6`] {
2905	static const ActivationFunctionType values[] = {
2906	ActivationFunctionType_NONE,
2907	ActivationFunctionType_RELU,
2908	ActivationFunctionType_RELU_N1_TO_1,
2909	ActivationFunctionType_RELU6,
2910	ActivationFunctionType_TANH,
2911	ActivationFunctionType_SIGN_BIT
2912	};
2913	return values;
2914	}
2915
2916	inline const char * const *EnumNamesActivationFunctionType() {
2917	static const char * const names[`7`] = {
2918	"NONE",
2919	"RELU",
2920	"RELU_N1_TO_1",
2921	"RELU6",
2922	"TANH",
2923	"SIGN_BIT",
2924	nullptr
2925	};
2926	return names;
2927	}
2928
2929	inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) {
2930	if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT)) return "";
2931	const size_t index = static_cast<size_t>(e);
2932	return EnumNamesActivationFunctionType()[index];
2933	}
2934
2935	enum LSHProjectionType {
2936	LSHProjectionType_UNKNOWN = `0`,
2937	LSHProjectionType_SPARSE = `1`,
2938	LSHProjectionType_DENSE = `2`,
2939	LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
2940	LSHProjectionType_MAX = LSHProjectionType_DENSE
2941	};
2942
2943	inline const LSHProjectionType (&EnumValuesLSHProjectionType())[`3`] {
2944	static const LSHProjectionType values[] = {
2945	LSHProjectionType_UNKNOWN,
2946	LSHProjectionType_SPARSE,
2947	LSHProjectionType_DENSE
2948	};
2949	return values;
2950	}
2951
2952	inline const char * const *EnumNamesLSHProjectionType() {
2953	static const char * const names[`4`] = {
2954	"UNKNOWN",
2955	"SPARSE",
2956	"DENSE",
2957	nullptr
2958	};
2959	return names;
2960	}
2961
2962	inline const char *EnumNameLSHProjectionType(LSHProjectionType e) {
2963	if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE)) return "";
2964	const size_t index = static_cast<size_t>(e);
2965	return EnumNamesLSHProjectionType()[index];
2966	}
2967
2968	enum FullyConnectedOptionsWeightsFormat {
2969	FullyConnectedOptionsWeightsFormat_DEFAULT = `0`,
2970	FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = `1`,
2971	FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
2972	FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
2973	};
2974
2975	inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[`2`] {
2976	static const FullyConnectedOptionsWeightsFormat values[] = {
2977	FullyConnectedOptionsWeightsFormat_DEFAULT,
2978	FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
2979	};
2980	return values;
2981	}
2982
2983	inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() {
2984	static const char * const names[`3`] = {
2985	"DEFAULT",
2986	"SHUFFLED4x16INT8",
2987	nullptr
2988	};
2989	return names;
2990	}
2991
2992	inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) {
2993	if (flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8)) return "";
2994	const size_t index = static_cast<size_t>(e);
2995	return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
2996	}
2997
2998	enum LSTMKernelType {
2999	LSTMKernelType_FULL = `0`,
3000	LSTMKernelType_BASIC = `1`,
3001	LSTMKernelType_MIN = LSTMKernelType_FULL,
3002	LSTMKernelType_MAX = LSTMKernelType_BASIC
3003	};
3004
3005	inline const LSTMKernelType (&EnumValuesLSTMKernelType())[`2`] {
3006	static const LSTMKernelType values[] = {
3007	LSTMKernelType_FULL,
3008	LSTMKernelType_BASIC
3009	};
3010	return values;
3011	}
3012
3013	inline const char * const *EnumNamesLSTMKernelType() {
3014	static const char * const names[`3`] = {
3015	"FULL",
3016	"BASIC",
3017	nullptr
3018	};
3019	return names;
3020	}
3021
3022	inline const char *EnumNameLSTMKernelType(LSTMKernelType e) {
3023	if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC)) return "";
3024	const size_t index = static_cast<size_t>(e);
3025	return EnumNamesLSTMKernelType()[index];
3026	}
3027
3028	enum CombinerType {
3029	CombinerType_SUM = `0`,
3030	CombinerType_MEAN = `1`,
3031	CombinerType_SQRTN = `2`,
3032	CombinerType_MIN = CombinerType_SUM,
3033	CombinerType_MAX = CombinerType_SQRTN
3034	};
3035
3036	inline const CombinerType (&EnumValuesCombinerType())[`3`] {
3037	static const CombinerType values[] = {
3038	CombinerType_SUM,
3039	CombinerType_MEAN,
3040	CombinerType_SQRTN
3041	};
3042	return values;
3043	}
3044
3045	inline const char * const *EnumNamesCombinerType() {
3046	static const char * const names[`4`] = {
3047	"SUM",
3048	"MEAN",
3049	"SQRTN",
3050	nullptr
3051	};
3052	return names;
3053	}
3054
3055	inline const char *EnumNameCombinerType(CombinerType e) {
3056	if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN)) return "";
3057	const size_t index = static_cast<size_t>(e);
3058	return EnumNamesCombinerType()[index];
3059	}
3060
3061	enum MirrorPadMode {
3062	MirrorPadMode_REFLECT = `0`,
3063	MirrorPadMode_SYMMETRIC = `1`,
3064	MirrorPadMode_MIN = MirrorPadMode_REFLECT,
3065	MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
3066	};
3067
3068	inline const MirrorPadMode (&EnumValuesMirrorPadMode())[`2`] {
3069	static const MirrorPadMode values[] = {
3070	MirrorPadMode_REFLECT,
3071	MirrorPadMode_SYMMETRIC
3072	};
3073	return values;
3074	}
3075
3076	inline const char * const *EnumNamesMirrorPadMode() {
3077	static const char * const names[`3`] = {
3078	"REFLECT",
3079	"SYMMETRIC",
3080	nullptr
3081	};
3082	return names;
3083	}
3084
3085	inline const char *EnumNameMirrorPadMode(MirrorPadMode e) {
3086	if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC)) return "";
3087	const size_t index = static_cast<size_t>(e);
3088	return EnumNamesMirrorPadMode()[index];
3089	}
3090
3091	enum CustomOptionsFormat {
3092	CustomOptionsFormat_FLEXBUFFERS = `0`,
3093	CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
3094	CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
3095	};
3096
3097	inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[`1`] {
3098	static const CustomOptionsFormat values[] = {
3099	CustomOptionsFormat_FLEXBUFFERS
3100	};
3101	return values;
3102	}
3103
3104	inline const char * const *EnumNamesCustomOptionsFormat() {
3105	static const char * const names[`2`] = {
3106	"FLEXBUFFERS",
3107	nullptr
3108	};
3109	return names;
3110	}
3111
3112	inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) {
3113	if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS)) return "";
3114	const size_t index = static_cast<size_t>(e);
3115	return EnumNamesCustomOptionsFormat()[index];
3116	}
3117
3118	struct CustomQuantizationT : public flatbuffers::NativeTable {
3119	typedef CustomQuantization TableType;
3120	std::vector<uint8_t> custom;
3121	CustomQuantizationT() {
3122	}
3123	};
3124
3125	struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3126	typedef CustomQuantizationT NativeTableType;
3127	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3128	VT_CUSTOM = `4`
3129	};
3130	const flatbuffers::Vector<uint8_t> custom() const* {
3131	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
3132	}
3133	bool Verify(flatbuffers::Verifier &verifier) const {
3134	return VerifyTableStart(verifier) &&
3135	VerifyOffset(verifier, VT_CUSTOM) &&
3136	verifier.VerifyVector(custom()) &&
3137	verifier.EndTable();
3138	}
3139	CustomQuantizationT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3140	void UnPackTo(CustomQuantizationT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3141	static flatbuffers::Offset<CustomQuantization> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3142	};
3143
3144	struct CustomQuantizationBuilder {
3145	flatbuffers::FlatBufferBuilder &fbb_;
3146	flatbuffers::uoffset_t start_;
3147	void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom) {
3148	fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
3149	}
3150	explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3151	: fbb_(_fbb) {
3152	start_ = fbb_.StartTable();
3153	}
3154	CustomQuantizationBuilder &operator=(const CustomQuantizationBuilder &);
3155	flatbuffers::Offset<CustomQuantization> Finish() {
3156	const auto end = fbb_.EndTable(start_);
3157	auto o = flatbuffers::Offset<CustomQuantization>(end);
3158	return o;
3159	}
3160	};
3161
3162	inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
3163	flatbuffers::FlatBufferBuilder &_fbb,
3164	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = `0`) {
3165	CustomQuantizationBuilder builder_(_fbb);
3166	builder_.add_custom(custom);
3167	return builder_.Finish();
3168	}
3169
3170	inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
3171	flatbuffers::FlatBufferBuilder &_fbb,
3172	const std::vector<uint8_t> custom = nullptr*) {
3173	if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), `16`); }
3174	auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : `0`;
3175	return tflite::CreateCustomQuantization(
3176	_fbb,
3177	custom__);
3178	}
3179
3180	flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3181
3182	struct QuantizationParametersT : public flatbuffers::NativeTable {
3183	typedef QuantizationParameters TableType;
3184	std::vector<float> min;
3185	std::vector<float> max;
3186	std::vector<float> scale;
3187	std::vector<int64_t> zero_point;
3188	tflite::QuantizationDetailsUnion details;
3189	int32_t quantized_dimension;
3190	QuantizationParametersT()
3191	: quantized_dimension(`0`) {
3192	}
3193	};
3194
3195	struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3196	typedef QuantizationParametersT NativeTableType;
3197	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3198	VT_MIN = `4`,
3199	VT_MAX = `6`,
3200	VT_SCALE = `8`,
3201	VT_ZERO_POINT = `10`,
3202	VT_DETAILS_TYPE = `12`,
3203	VT_DETAILS = `14`,
3204	VT_QUANTIZED_DIMENSION = `16`
3205	};
3206	const flatbuffers::Vector<float> min() const* {
3207	return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
3208	}
3209	const flatbuffers::Vector<float> max() const* {
3210	return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
3211	}
3212	const flatbuffers::Vector<float> scale() const* {
3213	return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
3214	}
3215	const flatbuffers::Vector<int64_t> zero_point() const* {
3216	return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
3217	}
3218	tflite::QuantizationDetails details_type() const {
3219	return static_cast<tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, `0`));
3220	}
3221	const void details() const* {
3222	return GetPointer<const void *>(VT_DETAILS);
3223	}
3224	template<typename T> const T details_as() const*;
3225	const tflite::CustomQuantization details_as_CustomQuantization() const* {
3226	return details_type() == tflite::QuantizationDetails_CustomQuantization ? static_cast<const tflite::CustomQuantization >(details()) : nullptr*;
3227	}
3228	int32_t quantized_dimension() const {
3229	return GetField<int32_t>(VT_QUANTIZED_DIMENSION, `0`);
3230	}
3231	bool Verify(flatbuffers::Verifier &verifier) const {
3232	return VerifyTableStart(verifier) &&
3233	VerifyOffset(verifier, VT_MIN) &&
3234	verifier.VerifyVector(min()) &&
3235	VerifyOffset(verifier, VT_MAX) &&
3236	verifier.VerifyVector(max()) &&
3237	VerifyOffset(verifier, VT_SCALE) &&
3238	verifier.VerifyVector(scale()) &&
3239	VerifyOffset(verifier, VT_ZERO_POINT) &&
3240	verifier.VerifyVector(zero_point()) &&
3241	VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
3242	VerifyOffset(verifier, VT_DETAILS) &&
3243	VerifyQuantizationDetails(verifier, details(), details_type()) &&
3244	VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) &&
3245	verifier.EndTable();
3246	}
3247	QuantizationParametersT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3248	void UnPackTo(QuantizationParametersT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3249	static flatbuffers::Offset<QuantizationParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3250	};
3251
3252	template<> inline const tflite::CustomQuantization QuantizationParameters::details_as<tflite::CustomQuantization>() const* {
3253	return details_as_CustomQuantization();
3254	}
3255
3256	struct QuantizationParametersBuilder {
3257	flatbuffers::FlatBufferBuilder &fbb_;
3258	flatbuffers::uoffset_t start_;
3259	void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
3260	fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
3261	}
3262	void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
3263	fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
3264	}
3265	void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) {
3266	fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
3267	}
3268	void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point) {
3269	fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
3270	}
3271	void add_details_type(tflite::QuantizationDetails details_type) {
3272	fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), `0`);
3273	}
3274	void add_details(flatbuffers::Offset<void> details) {
3275	fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
3276	}
3277	void add_quantized_dimension(int32_t quantized_dimension) {
3278	fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, `0`);
3279	}
3280	explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3281	: fbb_(_fbb) {
3282	start_ = fbb_.StartTable();
3283	}
3284	QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &);
3285	flatbuffers::Offset<QuantizationParameters> Finish() {
3286	const auto end = fbb_.EndTable(start_);
3287	auto o = flatbuffers::Offset<QuantizationParameters>(end);
3288	return o;
3289	}
3290	};
3291
3292	inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
3293	flatbuffers::FlatBufferBuilder &_fbb,
3294	flatbuffers::Offset<flatbuffers::Vector<float>> min = `0`,
3295	flatbuffers::Offset<flatbuffers::Vector<float>> max = `0`,
3296	flatbuffers::Offset<flatbuffers::Vector<float>> scale = `0`,
3297	flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = `0`,
3298	tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
3299	flatbuffers::Offset<void> details = `0`,
3300	int32_t quantized_dimension = `0`) {
3301	QuantizationParametersBuilder builder_(_fbb);
3302	builder_.add_quantized_dimension(quantized_dimension);
3303	builder_.add_details(details);
3304	builder_.add_zero_point(zero_point);
3305	builder_.add_scale(scale);
3306	builder_.add_max(max);
3307	builder_.add_min(min);
3308	builder_.add_details_type(details_type);
3309	return builder_.Finish();
3310	}
3311
3312	inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
3313	flatbuffers::FlatBufferBuilder &_fbb,
3314	const std::vector<float> min = nullptr*,
3315	const std::vector<float> max = nullptr*,
3316	const std::vector<float> scale = nullptr*,
3317	const std::vector<int64_t> zero_point = nullptr*,
3318	tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
3319	flatbuffers::Offset<void> details = `0`,
3320	int32_t quantized_dimension = `0`) {
3321	auto min__ = min ? _fbb.CreateVector<float>(*min) : `0`;
3322	auto max__ = max ? _fbb.CreateVector<float>(*max) : `0`;
3323	auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : `0`;
3324	auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : `0`;
3325	return tflite::CreateQuantizationParameters(
3326	_fbb,
3327	min__,
3328	max__,
3329	scale__,
3330	zero_point__,
3331	details_type,
3332	details,
3333	quantized_dimension);
3334	}
3335
3336	flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3337
3338	struct Int32VectorT : public flatbuffers::NativeTable {
3339	typedef Int32Vector TableType;
3340	std::vector<int32_t> values;
3341	Int32VectorT() {
3342	}
3343	};
3344
3345	struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3346	typedef Int32VectorT NativeTableType;
3347	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3348	VT_VALUES = `4`
3349	};
3350	const flatbuffers::Vector<int32_t> values() const* {
3351	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
3352	}
3353	bool Verify(flatbuffers::Verifier &verifier) const {
3354	return VerifyTableStart(verifier) &&
3355	VerifyOffset(verifier, VT_VALUES) &&
3356	verifier.VerifyVector(values()) &&
3357	verifier.EndTable();
3358	}
3359	Int32VectorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3360	void UnPackTo(Int32VectorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3361	static flatbuffers::Offset<Int32Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3362	};
3363
3364	struct Int32VectorBuilder {
3365	flatbuffers::FlatBufferBuilder &fbb_;
3366	flatbuffers::uoffset_t start_;
3367	void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values) {
3368	fbb_.AddOffset(Int32Vector::VT_VALUES, values);
3369	}
3370	explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3371	: fbb_(_fbb) {
3372	start_ = fbb_.StartTable();
3373	}
3374	Int32VectorBuilder &operator=(const Int32VectorBuilder &);
3375	flatbuffers::Offset<Int32Vector> Finish() {
3376	const auto end = fbb_.EndTable(start_);
3377	auto o = flatbuffers::Offset<Int32Vector>(end);
3378	return o;
3379	}
3380	};
3381
3382	inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(
3383	flatbuffers::FlatBufferBuilder &_fbb,
3384	flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = `0`) {
3385	Int32VectorBuilder builder_(_fbb);
3386	builder_.add_values(values);
3387	return builder_.Finish();
3388	}
3389
3390	inline flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
3391	flatbuffers::FlatBufferBuilder &_fbb,
3392	const std::vector<int32_t> values = nullptr*) {
3393	auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : `0`;
3394	return tflite::CreateInt32Vector(
3395	_fbb,
3396	values__);
3397	}
3398
3399	flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3400
3401	struct Uint16VectorT : public flatbuffers::NativeTable {
3402	typedef Uint16Vector TableType;
3403	std::vector<uint16_t> values;
3404	Uint16VectorT() {
3405	}
3406	};
3407
3408	struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3409	typedef Uint16VectorT NativeTableType;
3410	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3411	VT_VALUES = `4`
3412	};
3413	const flatbuffers::Vector<uint16_t> values() const* {
3414	return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
3415	}
3416	bool Verify(flatbuffers::Verifier &verifier) const {
3417	return VerifyTableStart(verifier) &&
3418	VerifyOffset(verifier, VT_VALUES) &&
3419	verifier.VerifyVector(values()) &&
3420	verifier.EndTable();
3421	}
3422	Uint16VectorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3423	void UnPackTo(Uint16VectorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3424	static flatbuffers::Offset<Uint16Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3425	};
3426
3427	struct Uint16VectorBuilder {
3428	flatbuffers::FlatBufferBuilder &fbb_;
3429	flatbuffers::uoffset_t start_;
3430	void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values) {
3431	fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
3432	}
3433	explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3434	: fbb_(_fbb) {
3435	start_ = fbb_.StartTable();
3436	}
3437	Uint16VectorBuilder &operator=(const Uint16VectorBuilder &);
3438	flatbuffers::Offset<Uint16Vector> Finish() {
3439	const auto end = fbb_.EndTable(start_);
3440	auto o = flatbuffers::Offset<Uint16Vector>(end);
3441	return o;
3442	}
3443	};
3444
3445	inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
3446	flatbuffers::FlatBufferBuilder &_fbb,
3447	flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = `0`) {
3448	Uint16VectorBuilder builder_(_fbb);
3449	builder_.add_values(values);
3450	return builder_.Finish();
3451	}
3452
3453	inline flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
3454	flatbuffers::FlatBufferBuilder &_fbb,
3455	const std::vector<uint16_t> values = nullptr*) {
3456	if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), `4`); }
3457	auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : `0`;
3458	return tflite::CreateUint16Vector(
3459	_fbb,
3460	values__);
3461	}
3462
3463	flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3464
3465	struct Uint8VectorT : public flatbuffers::NativeTable {
3466	typedef Uint8Vector TableType;
3467	std::vector<uint8_t> values;
3468	Uint8VectorT() {
3469	}
3470	};
3471
3472	struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3473	typedef Uint8VectorT NativeTableType;
3474	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3475	VT_VALUES = `4`
3476	};
3477	const flatbuffers::Vector<uint8_t> values() const* {
3478	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
3479	}
3480	bool Verify(flatbuffers::Verifier &verifier) const {
3481	return VerifyTableStart(verifier) &&
3482	VerifyOffset(verifier, VT_VALUES) &&
3483	verifier.VerifyVector(values()) &&
3484	verifier.EndTable();
3485	}
3486	Uint8VectorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3487	void UnPackTo(Uint8VectorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3488	static flatbuffers::Offset<Uint8Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3489	};
3490
3491	struct Uint8VectorBuilder {
3492	flatbuffers::FlatBufferBuilder &fbb_;
3493	flatbuffers::uoffset_t start_;
3494	void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values) {
3495	fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
3496	}
3497	explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3498	: fbb_(_fbb) {
3499	start_ = fbb_.StartTable();
3500	}
3501	Uint8VectorBuilder &operator=(const Uint8VectorBuilder &);
3502	flatbuffers::Offset<Uint8Vector> Finish() {
3503	const auto end = fbb_.EndTable(start_);
3504	auto o = flatbuffers::Offset<Uint8Vector>(end);
3505	return o;
3506	}
3507	};
3508
3509	inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
3510	flatbuffers::FlatBufferBuilder &_fbb,
3511	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = `0`) {
3512	Uint8VectorBuilder builder_(_fbb);
3513	builder_.add_values(values);
3514	return builder_.Finish();
3515	}
3516
3517	inline flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
3518	flatbuffers::FlatBufferBuilder &_fbb,
3519	const std::vector<uint8_t> values = nullptr*) {
3520	if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), `4`); }
3521	auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : `0`;
3522	return tflite::CreateUint8Vector(
3523	_fbb,
3524	values__);
3525	}
3526
3527	flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3528
3529	struct DimensionMetadataT : public flatbuffers::NativeTable {
3530	typedef DimensionMetadata TableType;
3531	tflite::DimensionType format;
3532	int32_t dense_size;
3533	tflite::SparseIndexVectorUnion array_segments;
3534	tflite::SparseIndexVectorUnion array_indices;
3535	DimensionMetadataT()
3536	: format(tflite::DimensionType_DENSE),
3537	dense_size(`0`) {
3538	}
3539	};
3540
3541	struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3542	typedef DimensionMetadataT NativeTableType;
3543	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3544	VT_FORMAT = `4`,
3545	VT_DENSE_SIZE = `6`,
3546	VT_ARRAY_SEGMENTS_TYPE = `8`,
3547	VT_ARRAY_SEGMENTS = `10`,
3548	VT_ARRAY_INDICES_TYPE = `12`,
3549	VT_ARRAY_INDICES = `14`
3550	};
3551	tflite::DimensionType format() const {
3552	return static_cast<tflite::DimensionType>(GetField<int8_t>(VT_FORMAT, `0`));
3553	}
3554	int32_t dense_size() const {
3555	return GetField<int32_t>(VT_DENSE_SIZE, `0`);
3556	}
3557	tflite::SparseIndexVector array_segments_type() const {
3558	return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, `0`));
3559	}
3560	const void array_segments() const* {
3561	return GetPointer<const void *>(VT_ARRAY_SEGMENTS);
3562	}
3563	template<typename T> const T array_segments_as() const*;
3564	const tflite::Int32Vector array_segments_as_Int32Vector() const* {
3565	return array_segments_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector >(array_segments()) : nullptr*;
3566	}
3567	const tflite::Uint16Vector array_segments_as_Uint16Vector() const* {
3568	return array_segments_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector >(array_segments()) : nullptr*;
3569	}
3570	const tflite::Uint8Vector array_segments_as_Uint8Vector() const* {
3571	return array_segments_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector >(array_segments()) : nullptr*;
3572	}
3573	tflite::SparseIndexVector array_indices_type() const {
3574	return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, `0`));
3575	}
3576	const void array_indices() const* {
3577	return GetPointer<const void *>(VT_ARRAY_INDICES);
3578	}
3579	template<typename T> const T array_indices_as() const*;
3580	const tflite::Int32Vector array_indices_as_Int32Vector() const* {
3581	return array_indices_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector >(array_indices()) : nullptr*;
3582	}
3583	const tflite::Uint16Vector array_indices_as_Uint16Vector() const* {
3584	return array_indices_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector >(array_indices()) : nullptr*;
3585	}
3586	const tflite::Uint8Vector array_indices_as_Uint8Vector() const* {
3587	return array_indices_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector >(array_indices()) : nullptr*;
3588	}
3589	bool Verify(flatbuffers::Verifier &verifier) const {
3590	return VerifyTableStart(verifier) &&
3591	VerifyField<int8_t>(verifier, VT_FORMAT) &&
3592	VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
3593	VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE) &&
3594	VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
3595	VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
3596	VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE) &&
3597	VerifyOffset(verifier, VT_ARRAY_INDICES) &&
3598	VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
3599	verifier.EndTable();
3600	}
3601	DimensionMetadataT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3602	void UnPackTo(DimensionMetadataT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3603	static flatbuffers::Offset<DimensionMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3604	};
3605
3606	template<> inline const tflite::Int32Vector DimensionMetadata::array_segments_as<tflite::Int32Vector>() const* {
3607	return array_segments_as_Int32Vector();
3608	}
3609
3610	template<> inline const tflite::Uint16Vector DimensionMetadata::array_segments_as<tflite::Uint16Vector>() const* {
3611	return array_segments_as_Uint16Vector();
3612	}
3613
3614	template<> inline const tflite::Uint8Vector DimensionMetadata::array_segments_as<tflite::Uint8Vector>() const* {
3615	return array_segments_as_Uint8Vector();
3616	}
3617
3618	template<> inline const tflite::Int32Vector DimensionMetadata::array_indices_as<tflite::Int32Vector>() const* {
3619	return array_indices_as_Int32Vector();
3620	}
3621
3622	template<> inline const tflite::Uint16Vector DimensionMetadata::array_indices_as<tflite::Uint16Vector>() const* {
3623	return array_indices_as_Uint16Vector();
3624	}
3625
3626	template<> inline const tflite::Uint8Vector DimensionMetadata::array_indices_as<tflite::Uint8Vector>() const* {
3627	return array_indices_as_Uint8Vector();
3628	}
3629
3630	struct DimensionMetadataBuilder {
3631	flatbuffers::FlatBufferBuilder &fbb_;
3632	flatbuffers::uoffset_t start_;
3633	void add_format(tflite::DimensionType format) {
3634	fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), `0`);
3635	}
3636	void add_dense_size(int32_t dense_size) {
3637	fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, `0`);
3638	}
3639	void add_array_segments_type(tflite::SparseIndexVector array_segments_type) {
3640	fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast<uint8_t>(array_segments_type), `0`);
3641	}
3642	void add_array_segments(flatbuffers::Offset<void> array_segments) {
3643	fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
3644	}
3645	void add_array_indices_type(tflite::SparseIndexVector array_indices_type) {
3646	fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast<uint8_t>(array_indices_type), `0`);
3647	}
3648	void add_array_indices(flatbuffers::Offset<void> array_indices) {
3649	fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
3650	}
3651	explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3652	: fbb_(_fbb) {
3653	start_ = fbb_.StartTable();
3654	}
3655	DimensionMetadataBuilder &operator=(const DimensionMetadataBuilder &);
3656	flatbuffers::Offset<DimensionMetadata> Finish() {
3657	const auto end = fbb_.EndTable(start_);
3658	auto o = flatbuffers::Offset<DimensionMetadata>(end);
3659	return o;
3660	}
3661	};
3662
3663	inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
3664	flatbuffers::FlatBufferBuilder &_fbb,
3665	tflite::DimensionType format = tflite::DimensionType_DENSE,
3666	int32_t dense_size = `0`,
3667	tflite::SparseIndexVector array_segments_type = tflite::SparseIndexVector_NONE,
3668	flatbuffers::Offset<void> array_segments = `0`,
3669	tflite::SparseIndexVector array_indices_type = tflite::SparseIndexVector_NONE,
3670	flatbuffers::Offset<void> array_indices = `0`) {
3671	DimensionMetadataBuilder builder_(_fbb);
3672	builder_.add_array_indices(array_indices);
3673	builder_.add_array_segments(array_segments);
3674	builder_.add_dense_size(dense_size);
3675	builder_.add_array_indices_type(array_indices_type);
3676	builder_.add_array_segments_type(array_segments_type);
3677	builder_.add_format(format);
3678	return builder_.Finish();
3679	}
3680
3681	flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3682
3683	struct SparsityParametersT : public flatbuffers::NativeTable {
3684	typedef SparsityParameters TableType;
3685	std::vector<int32_t> traversal_order;
3686	std::vector<int32_t> block_map;
3687	std::vector<std::unique_ptr<tflite::DimensionMetadataT>> dim_metadata;
3688	SparsityParametersT() {
3689	}
3690	};
3691
3692	struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3693	typedef SparsityParametersT NativeTableType;
3694	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3695	VT_TRAVERSAL_ORDER = `4`,
3696	VT_BLOCK_MAP = `6`,
3697	VT_DIM_METADATA = `8`
3698	};
3699	const flatbuffers::Vector<int32_t> traversal_order() const* {
3700	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
3701	}
3702	const flatbuffers::Vector<int32_t> block_map() const* {
3703	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
3704	}
3705	const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> dim_metadata() const* {
3706	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
3707	}
3708	bool Verify(flatbuffers::Verifier &verifier) const {
3709	return VerifyTableStart(verifier) &&
3710	VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
3711	verifier.VerifyVector(traversal_order()) &&
3712	VerifyOffset(verifier, VT_BLOCK_MAP) &&
3713	verifier.VerifyVector(block_map()) &&
3714	VerifyOffset(verifier, VT_DIM_METADATA) &&
3715	verifier.VerifyVector(dim_metadata()) &&
3716	verifier.VerifyVectorOfTables(dim_metadata()) &&
3717	verifier.EndTable();
3718	}
3719	SparsityParametersT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3720	void UnPackTo(SparsityParametersT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3721	static flatbuffers::Offset<SparsityParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3722	};
3723
3724	struct SparsityParametersBuilder {
3725	flatbuffers::FlatBufferBuilder &fbb_;
3726	flatbuffers::uoffset_t start_;
3727	void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order) {
3728	fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
3729	}
3730	void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map) {
3731	fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
3732	}
3733	void add_dim_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata) {
3734	fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
3735	}
3736	explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3737	: fbb_(_fbb) {
3738	start_ = fbb_.StartTable();
3739	}
3740	SparsityParametersBuilder &operator=(const SparsityParametersBuilder &);
3741	flatbuffers::Offset<SparsityParameters> Finish() {
3742	const auto end = fbb_.EndTable(start_);
3743	auto o = flatbuffers::Offset<SparsityParameters>(end);
3744	return o;
3745	}
3746	};
3747
3748	inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
3749	flatbuffers::FlatBufferBuilder &_fbb,
3750	flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = `0`,
3751	flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = `0`,
3752	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = `0`) {
3753	SparsityParametersBuilder builder_(_fbb);
3754	builder_.add_dim_metadata(dim_metadata);
3755	builder_.add_block_map(block_map);
3756	builder_.add_traversal_order(traversal_order);
3757	return builder_.Finish();
3758	}
3759
3760	inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
3761	flatbuffers::FlatBufferBuilder &_fbb,
3762	const std::vector<int32_t> traversal_order = nullptr*,
3763	const std::vector<int32_t> block_map = nullptr*,
3764	const std::vector<flatbuffers::Offset<tflite::DimensionMetadata>> dim_metadata = nullptr*) {
3765	auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : `0`;
3766	auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : `0`;
3767	auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : `0`;
3768	return tflite::CreateSparsityParameters(
3769	_fbb,
3770	traversal_order__,
3771	block_map__,
3772	dim_metadata__);
3773	}
3774
3775	flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3776
3777	struct TensorT : public flatbuffers::NativeTable {
3778	typedef Tensor TableType;
3779	std::vector<int32_t> shape;
3780	tflite::TensorType type;
3781	uint32_t buffer;
3782	std::string name;
3783	std::unique_ptr<tflite::QuantizationParametersT> quantization;
3784	bool is_variable;
3785	std::unique_ptr<tflite::SparsityParametersT> sparsity;
3786	std::vector<int32_t> shape_signature;
3787	TensorT()
3788	: type(tflite::TensorType_FLOAT32),
3789	buffer(`0`),
3790	is_variable(false) {
3791	}
3792	};
3793
3794	struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3795	typedef TensorT NativeTableType;
3796	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3797	VT_SHAPE = `4`,
3798	VT_TYPE = `6`,
3799	VT_BUFFER = `8`,
3800	VT_NAME = `10`,
3801	VT_QUANTIZATION = `12`,
3802	VT_IS_VARIABLE = `14`,
3803	VT_SPARSITY = `16`,
3804	VT_SHAPE_SIGNATURE = `18`
3805	};
3806	const flatbuffers::Vector<int32_t> shape() const* {
3807	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
3808	}
3809	tflite::TensorType type() const {
3810	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, `0`));
3811	}
3812	uint32_t buffer() const {
3813	return GetField<uint32_t>(VT_BUFFER, `0`);
3814	}
3815	const flatbuffers::String name() const* {
3816	return GetPointer<const flatbuffers::String *>(VT_NAME);
3817	}
3818	const tflite::QuantizationParameters quantization() const* {
3819	return GetPointer<const tflite::QuantizationParameters *>(VT_QUANTIZATION);
3820	}
3821	bool is_variable() const {
3822	return GetField<uint8_t>(VT_IS_VARIABLE, `0`) != `0`;
3823	}
3824	const tflite::SparsityParameters sparsity() const* {
3825	return GetPointer<const tflite::SparsityParameters *>(VT_SPARSITY);
3826	}
3827	const flatbuffers::Vector<int32_t> shape_signature() const* {
3828	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
3829	}
3830	bool Verify(flatbuffers::Verifier &verifier) const {
3831	return VerifyTableStart(verifier) &&
3832	VerifyOffset(verifier, VT_SHAPE) &&
3833	verifier.VerifyVector(shape()) &&
3834	VerifyField<int8_t>(verifier, VT_TYPE) &&
3835	VerifyField<uint32_t>(verifier, VT_BUFFER) &&
3836	VerifyOffset(verifier, VT_NAME) &&
3837	verifier.VerifyString(name()) &&
3838	VerifyOffset(verifier, VT_QUANTIZATION) &&
3839	verifier.VerifyTable(quantization()) &&
3840	VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
3841	VerifyOffset(verifier, VT_SPARSITY) &&
3842	verifier.VerifyTable(sparsity()) &&
3843	VerifyOffset(verifier, VT_SHAPE_SIGNATURE) &&
3844	verifier.VerifyVector(shape_signature()) &&
3845	verifier.EndTable();
3846	}
3847	TensorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3848	void UnPackTo(TensorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3849	static flatbuffers::Offset<Tensor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3850	};
3851
3852	struct TensorBuilder {
3853	flatbuffers::FlatBufferBuilder &fbb_;
3854	flatbuffers::uoffset_t start_;
3855	void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
3856	fbb_.AddOffset(Tensor::VT_SHAPE, shape);
3857	}
3858	void add_type(tflite::TensorType type) {
3859	fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), `0`);
3860	}
3861	void add_buffer(uint32_t buffer) {
3862	fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, `0`);
3863	}
3864	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
3865	fbb_.AddOffset(Tensor::VT_NAME, name);
3866	}
3867	void add_quantization(flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
3868	fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
3869	}
3870	void add_is_variable(bool is_variable) {
3871	fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), `0`);
3872	}
3873	void add_sparsity(flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
3874	fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
3875	}
3876	void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature) {
3877	fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
3878	}
3879	explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3880	: fbb_(_fbb) {
3881	start_ = fbb_.StartTable();
3882	}
3883	TensorBuilder &operator=(const TensorBuilder &);
3884	flatbuffers::Offset<Tensor> Finish() {
3885	const auto end = fbb_.EndTable(start_);
3886	auto o = flatbuffers::Offset<Tensor>(end);
3887	return o;
3888	}
3889	};
3890
3891	inline flatbuffers::Offset<Tensor> CreateTensor(
3892	flatbuffers::FlatBufferBuilder &_fbb,
3893	flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = `0`,
3894	tflite::TensorType type = tflite::TensorType_FLOAT32,
3895	uint32_t buffer = `0`,
3896	flatbuffers::Offset<flatbuffers::String> name = `0`,
3897	flatbuffers::Offset<tflite::QuantizationParameters> quantization = `0`,
3898	bool is_variable = false,
3899	flatbuffers::Offset<tflite::SparsityParameters> sparsity = `0`,
3900	flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = `0`) {
3901	TensorBuilder builder_(_fbb);
3902	builder_.add_shape_signature(shape_signature);
3903	builder_.add_sparsity(sparsity);
3904	builder_.add_quantization(quantization);
3905	builder_.add_name(name);
3906	builder_.add_buffer(buffer);
3907	builder_.add_shape(shape);
3908	builder_.add_is_variable(is_variable);
3909	builder_.add_type(type);
3910	return builder_.Finish();
3911	}
3912
3913	inline flatbuffers::Offset<Tensor> CreateTensorDirect(
3914	flatbuffers::FlatBufferBuilder &_fbb,
3915	const std::vector<int32_t> shape = nullptr*,
3916	tflite::TensorType type = tflite::TensorType_FLOAT32,
3917	uint32_t buffer = `0`,
3918	const char name = nullptr*,
3919	flatbuffers::Offset<tflite::QuantizationParameters> quantization = `0`,
3920	bool is_variable = false,
3921	flatbuffers::Offset<tflite::SparsityParameters> sparsity = `0`,
3922	const std::vector<int32_t> shape_signature = nullptr*) {
3923	auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : `0`;
3924	auto name__ = name ? _fbb.CreateString(name) : `0`;
3925	auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : `0`;
3926	return tflite::CreateTensor(
3927	_fbb,
3928	shape__,
3929	type,
3930	buffer,
3931	name__,
3932	quantization,
3933	is_variable,
3934	sparsity,
3935	shape_signature__);
3936	}
3937
3938	flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
3939
3940	struct Conv2DOptionsT : public flatbuffers::NativeTable {
3941	typedef Conv2DOptions TableType;
3942	tflite::Padding padding;
3943	int32_t stride_w;
3944	int32_t stride_h;
3945	tflite::ActivationFunctionType fused_activation_function;
3946	int32_t dilation_w_factor;
3947	int32_t dilation_h_factor;
3948	Conv2DOptionsT()
3949	: padding(tflite::Padding_SAME),
3950	stride_w(`0`),
3951	stride_h(`0`),
3952	fused_activation_function(tflite::ActivationFunctionType_NONE),
3953	dilation_w_factor(`1`),
3954	dilation_h_factor(`1`) {
3955	}
3956	};
3957
3958	struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3959	typedef Conv2DOptionsT NativeTableType;
3960	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3961	VT_PADDING = `4`,
3962	VT_STRIDE_W = `6`,
3963	VT_STRIDE_H = `8`,
3964	VT_FUSED_ACTIVATION_FUNCTION = `10`,
3965	VT_DILATION_W_FACTOR = `12`,
3966	VT_DILATION_H_FACTOR = `14`
3967	};
3968	tflite::Padding padding() const {
3969	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
3970	}
3971	int32_t stride_w() const {
3972	return GetField<int32_t>(VT_STRIDE_W, `0`);
3973	}
3974	int32_t stride_h() const {
3975	return GetField<int32_t>(VT_STRIDE_H, `0`);
3976	}
3977	tflite::ActivationFunctionType fused_activation_function() const {
3978	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
3979	}
3980	int32_t dilation_w_factor() const {
3981	return GetField<int32_t>(VT_DILATION_W_FACTOR, `1`);
3982	}
3983	int32_t dilation_h_factor() const {
3984	return GetField<int32_t>(VT_DILATION_H_FACTOR, `1`);
3985	}
3986	bool Verify(flatbuffers::Verifier &verifier) const {
3987	return VerifyTableStart(verifier) &&
3988	VerifyField<int8_t>(verifier, VT_PADDING) &&
3989	VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3990	VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3991	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3992	VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3993	VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
3994	verifier.EndTable();
3995	}
3996	Conv2DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3997	void UnPackTo(Conv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
3998	static flatbuffers::Offset<Conv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
3999	};
4000
4001	struct Conv2DOptionsBuilder {
4002	flatbuffers::FlatBufferBuilder &fbb_;
4003	flatbuffers::uoffset_t start_;
4004	void add_padding(tflite::Padding padding) {
4005	fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
4006	}
4007	void add_stride_w(int32_t stride_w) {
4008	fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, `0`);
4009	}
4010	void add_stride_h(int32_t stride_h) {
4011	fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, `0`);
4012	}
4013	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4014	fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4015	}
4016	void add_dilation_w_factor(int32_t dilation_w_factor) {
4017	fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, `1`);
4018	}
4019	void add_dilation_h_factor(int32_t dilation_h_factor) {
4020	fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, `1`);
4021	}
4022	explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4023	: fbb_(_fbb) {
4024	start_ = fbb_.StartTable();
4025	}
4026	Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &);
4027	flatbuffers::Offset<Conv2DOptions> Finish() {
4028	const auto end = fbb_.EndTable(start_);
4029	auto o = flatbuffers::Offset<Conv2DOptions>(end);
4030	return o;
4031	}
4032	};
4033
4034	inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
4035	flatbuffers::FlatBufferBuilder &_fbb,
4036	tflite::Padding padding = tflite::Padding_SAME,
4037	int32_t stride_w = `0`,
4038	int32_t stride_h = `0`,
4039	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4040	int32_t dilation_w_factor = `1`,
4041	int32_t dilation_h_factor = `1`) {
4042	Conv2DOptionsBuilder builder_(_fbb);
4043	builder_.add_dilation_h_factor(dilation_h_factor);
4044	builder_.add_dilation_w_factor(dilation_w_factor);
4045	builder_.add_stride_h(stride_h);
4046	builder_.add_stride_w(stride_w);
4047	builder_.add_fused_activation_function(fused_activation_function);
4048	builder_.add_padding(padding);
4049	return builder_.Finish();
4050	}
4051
4052	flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4053
4054	struct Conv3DOptionsT : public flatbuffers::NativeTable {
4055	typedef Conv3DOptions TableType;
4056	tflite::Padding padding;
4057	int32_t stride_d;
4058	int32_t stride_w;
4059	int32_t stride_h;
4060	tflite::ActivationFunctionType fused_activation_function;
4061	int32_t dilation_d_factor;
4062	int32_t dilation_w_factor;
4063	int32_t dilation_h_factor;
4064	Conv3DOptionsT()
4065	: padding(tflite::Padding_SAME),
4066	stride_d(`0`),
4067	stride_w(`0`),
4068	stride_h(`0`),
4069	fused_activation_function(tflite::ActivationFunctionType_NONE),
4070	dilation_d_factor(`1`),
4071	dilation_w_factor(`1`),
4072	dilation_h_factor(`1`) {
4073	}
4074	};
4075
4076	struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4077	typedef Conv3DOptionsT NativeTableType;
4078	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4079	VT_PADDING = `4`,
4080	VT_STRIDE_D = `6`,
4081	VT_STRIDE_W = `8`,
4082	VT_STRIDE_H = `10`,
4083	VT_FUSED_ACTIVATION_FUNCTION = `12`,
4084	VT_DILATION_D_FACTOR = `14`,
4085	VT_DILATION_W_FACTOR = `16`,
4086	VT_DILATION_H_FACTOR = `18`
4087	};
4088	tflite::Padding padding() const {
4089	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
4090	}
4091	int32_t stride_d() const {
4092	return GetField<int32_t>(VT_STRIDE_D, `0`);
4093	}
4094	int32_t stride_w() const {
4095	return GetField<int32_t>(VT_STRIDE_W, `0`);
4096	}
4097	int32_t stride_h() const {
4098	return GetField<int32_t>(VT_STRIDE_H, `0`);
4099	}
4100	tflite::ActivationFunctionType fused_activation_function() const {
4101	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4102	}
4103	int32_t dilation_d_factor() const {
4104	return GetField<int32_t>(VT_DILATION_D_FACTOR, `1`);
4105	}
4106	int32_t dilation_w_factor() const {
4107	return GetField<int32_t>(VT_DILATION_W_FACTOR, `1`);
4108	}
4109	int32_t dilation_h_factor() const {
4110	return GetField<int32_t>(VT_DILATION_H_FACTOR, `1`);
4111	}
4112	bool Verify(flatbuffers::Verifier &verifier) const {
4113	return VerifyTableStart(verifier) &&
4114	VerifyField<int8_t>(verifier, VT_PADDING) &&
4115	VerifyField<int32_t>(verifier, VT_STRIDE_D) &&
4116	VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
4117	VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
4118	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4119	VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR) &&
4120	VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
4121	VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
4122	verifier.EndTable();
4123	}
4124	Conv3DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4125	void UnPackTo(Conv3DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4126	static flatbuffers::Offset<Conv3DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4127	};
4128
4129	struct Conv3DOptionsBuilder {
4130	flatbuffers::FlatBufferBuilder &fbb_;
4131	flatbuffers::uoffset_t start_;
4132	void add_padding(tflite::Padding padding) {
4133	fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
4134	}
4135	void add_stride_d(int32_t stride_d) {
4136	fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, `0`);
4137	}
4138	void add_stride_w(int32_t stride_w) {
4139	fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, `0`);
4140	}
4141	void add_stride_h(int32_t stride_h) {
4142	fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, `0`);
4143	}
4144	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4145	fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4146	}
4147	void add_dilation_d_factor(int32_t dilation_d_factor) {
4148	fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, `1`);
4149	}
4150	void add_dilation_w_factor(int32_t dilation_w_factor) {
4151	fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, `1`);
4152	}
4153	void add_dilation_h_factor(int32_t dilation_h_factor) {
4154	fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, `1`);
4155	}
4156	explicit Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4157	: fbb_(_fbb) {
4158	start_ = fbb_.StartTable();
4159	}
4160	Conv3DOptionsBuilder &operator=(const Conv3DOptionsBuilder &);
4161	flatbuffers::Offset<Conv3DOptions> Finish() {
4162	const auto end = fbb_.EndTable(start_);
4163	auto o = flatbuffers::Offset<Conv3DOptions>(end);
4164	return o;
4165	}
4166	};
4167
4168	inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
4169	flatbuffers::FlatBufferBuilder &_fbb,
4170	tflite::Padding padding = tflite::Padding_SAME,
4171	int32_t stride_d = `0`,
4172	int32_t stride_w = `0`,
4173	int32_t stride_h = `0`,
4174	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4175	int32_t dilation_d_factor = `1`,
4176	int32_t dilation_w_factor = `1`,
4177	int32_t dilation_h_factor = `1`) {
4178	Conv3DOptionsBuilder builder_(_fbb);
4179	builder_.add_dilation_h_factor(dilation_h_factor);
4180	builder_.add_dilation_w_factor(dilation_w_factor);
4181	builder_.add_dilation_d_factor(dilation_d_factor);
4182	builder_.add_stride_h(stride_h);
4183	builder_.add_stride_w(stride_w);
4184	builder_.add_stride_d(stride_d);
4185	builder_.add_fused_activation_function(fused_activation_function);
4186	builder_.add_padding(padding);
4187	return builder_.Finish();
4188	}
4189
4190	flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4191
4192	struct Pool2DOptionsT : public flatbuffers::NativeTable {
4193	typedef Pool2DOptions TableType;
4194	tflite::Padding padding;
4195	int32_t stride_w;
4196	int32_t stride_h;
4197	int32_t filter_width;
4198	int32_t filter_height;
4199	tflite::ActivationFunctionType fused_activation_function;
4200	Pool2DOptionsT()
4201	: padding(tflite::Padding_SAME),
4202	stride_w(`0`),
4203	stride_h(`0`),
4204	filter_width(`0`),
4205	filter_height(`0`),
4206	fused_activation_function(tflite::ActivationFunctionType_NONE) {
4207	}
4208	};
4209
4210	struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4211	typedef Pool2DOptionsT NativeTableType;
4212	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4213	VT_PADDING = `4`,
4214	VT_STRIDE_W = `6`,
4215	VT_STRIDE_H = `8`,
4216	VT_FILTER_WIDTH = `10`,
4217	VT_FILTER_HEIGHT = `12`,
4218	VT_FUSED_ACTIVATION_FUNCTION = `14`
4219	};
4220	tflite::Padding padding() const {
4221	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
4222	}
4223	int32_t stride_w() const {
4224	return GetField<int32_t>(VT_STRIDE_W, `0`);
4225	}
4226	int32_t stride_h() const {
4227	return GetField<int32_t>(VT_STRIDE_H, `0`);
4228	}
4229	int32_t filter_width() const {
4230	return GetField<int32_t>(VT_FILTER_WIDTH, `0`);
4231	}
4232	int32_t filter_height() const {
4233	return GetField<int32_t>(VT_FILTER_HEIGHT, `0`);
4234	}
4235	tflite::ActivationFunctionType fused_activation_function() const {
4236	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4237	}
4238	bool Verify(flatbuffers::Verifier &verifier) const {
4239	return VerifyTableStart(verifier) &&
4240	VerifyField<int8_t>(verifier, VT_PADDING) &&
4241	VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
4242	VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
4243	VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
4244	VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
4245	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4246	verifier.EndTable();
4247	}
4248	Pool2DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4249	void UnPackTo(Pool2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4250	static flatbuffers::Offset<Pool2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4251	};
4252
4253	struct Pool2DOptionsBuilder {
4254	flatbuffers::FlatBufferBuilder &fbb_;
4255	flatbuffers::uoffset_t start_;
4256	void add_padding(tflite::Padding padding) {
4257	fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
4258	}
4259	void add_stride_w(int32_t stride_w) {
4260	fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, `0`);
4261	}
4262	void add_stride_h(int32_t stride_h) {
4263	fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, `0`);
4264	}
4265	void add_filter_width(int32_t filter_width) {
4266	fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, `0`);
4267	}
4268	void add_filter_height(int32_t filter_height) {
4269	fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, `0`);
4270	}
4271	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4272	fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4273	}
4274	explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4275	: fbb_(_fbb) {
4276	start_ = fbb_.StartTable();
4277	}
4278	Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &);
4279	flatbuffers::Offset<Pool2DOptions> Finish() {
4280	const auto end = fbb_.EndTable(start_);
4281	auto o = flatbuffers::Offset<Pool2DOptions>(end);
4282	return o;
4283	}
4284	};
4285
4286	inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
4287	flatbuffers::FlatBufferBuilder &_fbb,
4288	tflite::Padding padding = tflite::Padding_SAME,
4289	int32_t stride_w = `0`,
4290	int32_t stride_h = `0`,
4291	int32_t filter_width = `0`,
4292	int32_t filter_height = `0`,
4293	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
4294	Pool2DOptionsBuilder builder_(_fbb);
4295	builder_.add_filter_height(filter_height);
4296	builder_.add_filter_width(filter_width);
4297	builder_.add_stride_h(stride_h);
4298	builder_.add_stride_w(stride_w);
4299	builder_.add_fused_activation_function(fused_activation_function);
4300	builder_.add_padding(padding);
4301	return builder_.Finish();
4302	}
4303
4304	flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4305
4306	struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable {
4307	typedef DepthwiseConv2DOptions TableType;
4308	tflite::Padding padding;
4309	int32_t stride_w;
4310	int32_t stride_h;
4311	int32_t depth_multiplier;
4312	tflite::ActivationFunctionType fused_activation_function;
4313	int32_t dilation_w_factor;
4314	int32_t dilation_h_factor;
4315	DepthwiseConv2DOptionsT()
4316	: padding(tflite::Padding_SAME),
4317	stride_w(`0`),
4318	stride_h(`0`),
4319	depth_multiplier(`0`),
4320	fused_activation_function(tflite::ActivationFunctionType_NONE),
4321	dilation_w_factor(`1`),
4322	dilation_h_factor(`1`) {
4323	}
4324	};
4325
4326	struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4327	typedef DepthwiseConv2DOptionsT NativeTableType;
4328	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4329	VT_PADDING = `4`,
4330	VT_STRIDE_W = `6`,
4331	VT_STRIDE_H = `8`,
4332	VT_DEPTH_MULTIPLIER = `10`,
4333	VT_FUSED_ACTIVATION_FUNCTION = `12`,
4334	VT_DILATION_W_FACTOR = `14`,
4335	VT_DILATION_H_FACTOR = `16`
4336	};
4337	tflite::Padding padding() const {
4338	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
4339	}
4340	int32_t stride_w() const {
4341	return GetField<int32_t>(VT_STRIDE_W, `0`);
4342	}
4343	int32_t stride_h() const {
4344	return GetField<int32_t>(VT_STRIDE_H, `0`);
4345	}
4346	int32_t depth_multiplier() const {
4347	return GetField<int32_t>(VT_DEPTH_MULTIPLIER, `0`);
4348	}
4349	tflite::ActivationFunctionType fused_activation_function() const {
4350	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4351	}
4352	int32_t dilation_w_factor() const {
4353	return GetField<int32_t>(VT_DILATION_W_FACTOR, `1`);
4354	}
4355	int32_t dilation_h_factor() const {
4356	return GetField<int32_t>(VT_DILATION_H_FACTOR, `1`);
4357	}
4358	bool Verify(flatbuffers::Verifier &verifier) const {
4359	return VerifyTableStart(verifier) &&
4360	VerifyField<int8_t>(verifier, VT_PADDING) &&
4361	VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
4362	VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
4363	VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
4364	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4365	VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
4366	VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) &&
4367	verifier.EndTable();
4368	}
4369	DepthwiseConv2DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4370	void UnPackTo(DepthwiseConv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4371	static flatbuffers::Offset<DepthwiseConv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4372	};
4373
4374	struct DepthwiseConv2DOptionsBuilder {
4375	flatbuffers::FlatBufferBuilder &fbb_;
4376	flatbuffers::uoffset_t start_;
4377	void add_padding(tflite::Padding padding) {
4378	fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
4379	}
4380	void add_stride_w(int32_t stride_w) {
4381	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, `0`);
4382	}
4383	void add_stride_h(int32_t stride_h) {
4384	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, `0`);
4385	}
4386	void add_depth_multiplier(int32_t depth_multiplier) {
4387	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, `0`);
4388	}
4389	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4390	fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4391	}
4392	void add_dilation_w_factor(int32_t dilation_w_factor) {
4393	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, `1`);
4394	}
4395	void add_dilation_h_factor(int32_t dilation_h_factor) {
4396	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, `1`);
4397	}
4398	explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4399	: fbb_(_fbb) {
4400	start_ = fbb_.StartTable();
4401	}
4402	DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &);
4403	flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
4404	const auto end = fbb_.EndTable(start_);
4405	auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
4406	return o;
4407	}
4408	};
4409
4410	inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
4411	flatbuffers::FlatBufferBuilder &_fbb,
4412	tflite::Padding padding = tflite::Padding_SAME,
4413	int32_t stride_w = `0`,
4414	int32_t stride_h = `0`,
4415	int32_t depth_multiplier = `0`,
4416	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4417	int32_t dilation_w_factor = `1`,
4418	int32_t dilation_h_factor = `1`) {
4419	DepthwiseConv2DOptionsBuilder builder_(_fbb);
4420	builder_.add_dilation_h_factor(dilation_h_factor);
4421	builder_.add_dilation_w_factor(dilation_w_factor);
4422	builder_.add_depth_multiplier(depth_multiplier);
4423	builder_.add_stride_h(stride_h);
4424	builder_.add_stride_w(stride_w);
4425	builder_.add_fused_activation_function(fused_activation_function);
4426	builder_.add_padding(padding);
4427	return builder_.Finish();
4428	}
4429
4430	flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4431
4432	struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable {
4433	typedef ConcatEmbeddingsOptions TableType;
4434	int32_t num_channels;
4435	std::vector<int32_t> num_columns_per_channel;
4436	std::vector<int32_t> embedding_dim_per_channel;
4437	ConcatEmbeddingsOptionsT()
4438	: num_channels(`0`) {
4439	}
4440	};
4441
4442	struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4443	typedef ConcatEmbeddingsOptionsT NativeTableType;
4444	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4445	VT_NUM_CHANNELS = `4`,
4446	VT_NUM_COLUMNS_PER_CHANNEL = `6`,
4447	VT_EMBEDDING_DIM_PER_CHANNEL = `8`
4448	};
4449	int32_t num_channels() const {
4450	return GetField<int32_t>(VT_NUM_CHANNELS, `0`);
4451	}
4452	const flatbuffers::Vector<int32_t> num_columns_per_channel() const* {
4453	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
4454	}
4455	const flatbuffers::Vector<int32_t> embedding_dim_per_channel() const* {
4456	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
4457	}
4458	bool Verify(flatbuffers::Verifier &verifier) const {
4459	return VerifyTableStart(verifier) &&
4460	VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
4461	VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
4462	verifier.VerifyVector(num_columns_per_channel()) &&
4463	VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
4464	verifier.VerifyVector(embedding_dim_per_channel()) &&
4465	verifier.EndTable();
4466	}
4467	ConcatEmbeddingsOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4468	void UnPackTo(ConcatEmbeddingsOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4469	static flatbuffers::Offset<ConcatEmbeddingsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4470	};
4471
4472	struct ConcatEmbeddingsOptionsBuilder {
4473	flatbuffers::FlatBufferBuilder &fbb_;
4474	flatbuffers::uoffset_t start_;
4475	void add_num_channels(int32_t num_channels) {
4476	fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, `0`);
4477	}
4478	void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) {
4479	fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
4480	}
4481	void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
4482	fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
4483	}
4484	explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4485	: fbb_(_fbb) {
4486	start_ = fbb_.StartTable();
4487	}
4488	ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &);
4489	flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
4490	const auto end = fbb_.EndTable(start_);
4491	auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
4492	return o;
4493	}
4494	};
4495
4496	inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
4497	flatbuffers::FlatBufferBuilder &_fbb,
4498	int32_t num_channels = `0`,
4499	flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = `0`,
4500	flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = `0`) {
4501	ConcatEmbeddingsOptionsBuilder builder_(_fbb);
4502	builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
4503	builder_.add_num_columns_per_channel(num_columns_per_channel);
4504	builder_.add_num_channels(num_channels);
4505	return builder_.Finish();
4506	}
4507
4508	inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
4509	flatbuffers::FlatBufferBuilder &_fbb,
4510	int32_t num_channels = `0`,
4511	const std::vector<int32_t> num_columns_per_channel = nullptr*,
4512	const std::vector<int32_t> embedding_dim_per_channel = nullptr*) {
4513	auto num_columns_per_channel__ = num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : `0`;
4514	auto embedding_dim_per_channel__ = embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : `0`;
4515	return tflite::CreateConcatEmbeddingsOptions(
4516	_fbb,
4517	num_channels,
4518	num_columns_per_channel__,
4519	embedding_dim_per_channel__);
4520	}
4521
4522	flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4523
4524	struct LSHProjectionOptionsT : public flatbuffers::NativeTable {
4525	typedef LSHProjectionOptions TableType;
4526	tflite::LSHProjectionType type;
4527	LSHProjectionOptionsT()
4528	: type(tflite::LSHProjectionType_UNKNOWN) {
4529	}
4530	};
4531
4532	struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4533	typedef LSHProjectionOptionsT NativeTableType;
4534	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4535	VT_TYPE = `4`
4536	};
4537	tflite::LSHProjectionType type() const {
4538	return static_cast<tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, `0`));
4539	}
4540	bool Verify(flatbuffers::Verifier &verifier) const {
4541	return VerifyTableStart(verifier) &&
4542	VerifyField<int8_t>(verifier, VT_TYPE) &&
4543	verifier.EndTable();
4544	}
4545	LSHProjectionOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4546	void UnPackTo(LSHProjectionOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4547	static flatbuffers::Offset<LSHProjectionOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4548	};
4549
4550	struct LSHProjectionOptionsBuilder {
4551	flatbuffers::FlatBufferBuilder &fbb_;
4552	flatbuffers::uoffset_t start_;
4553	void add_type(tflite::LSHProjectionType type) {
4554	fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), `0`);
4555	}
4556	explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4557	: fbb_(_fbb) {
4558	start_ = fbb_.StartTable();
4559	}
4560	LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &);
4561	flatbuffers::Offset<LSHProjectionOptions> Finish() {
4562	const auto end = fbb_.EndTable(start_);
4563	auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
4564	return o;
4565	}
4566	};
4567
4568	inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
4569	flatbuffers::FlatBufferBuilder &_fbb,
4570	tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN) {
4571	LSHProjectionOptionsBuilder builder_(_fbb);
4572	builder_.add_type(type);
4573	return builder_.Finish();
4574	}
4575
4576	flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4577
4578	struct SVDFOptionsT : public flatbuffers::NativeTable {
4579	typedef SVDFOptions TableType;
4580	int32_t rank;
4581	tflite::ActivationFunctionType fused_activation_function;
4582	bool asymmetric_quantize_inputs;
4583	SVDFOptionsT()
4584	: rank(`0`),
4585	fused_activation_function(tflite::ActivationFunctionType_NONE),
4586	asymmetric_quantize_inputs(false) {
4587	}
4588	};
4589
4590	struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4591	typedef SVDFOptionsT NativeTableType;
4592	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4593	VT_RANK = `4`,
4594	VT_FUSED_ACTIVATION_FUNCTION = `6`,
4595	VT_ASYMMETRIC_QUANTIZE_INPUTS = `8`
4596	};
4597	int32_t rank() const {
4598	return GetField<int32_t>(VT_RANK, `0`);
4599	}
4600	tflite::ActivationFunctionType fused_activation_function() const {
4601	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4602	}
4603	bool asymmetric_quantize_inputs() const {
4604	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
4605	}
4606	bool Verify(flatbuffers::Verifier &verifier) const {
4607	return VerifyTableStart(verifier) &&
4608	VerifyField<int32_t>(verifier, VT_RANK) &&
4609	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4610	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4611	verifier.EndTable();
4612	}
4613	SVDFOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4614	void UnPackTo(SVDFOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4615	static flatbuffers::Offset<SVDFOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4616	};
4617
4618	struct SVDFOptionsBuilder {
4619	flatbuffers::FlatBufferBuilder &fbb_;
4620	flatbuffers::uoffset_t start_;
4621	void add_rank(int32_t rank) {
4622	fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, `0`);
4623	}
4624	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4625	fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4626	}
4627	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4628	fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
4629	}
4630	explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4631	: fbb_(_fbb) {
4632	start_ = fbb_.StartTable();
4633	}
4634	SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &);
4635	flatbuffers::Offset<SVDFOptions> Finish() {
4636	const auto end = fbb_.EndTable(start_);
4637	auto o = flatbuffers::Offset<SVDFOptions>(end);
4638	return o;
4639	}
4640	};
4641
4642	inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
4643	flatbuffers::FlatBufferBuilder &_fbb,
4644	int32_t rank = `0`,
4645	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4646	bool asymmetric_quantize_inputs = false) {
4647	SVDFOptionsBuilder builder_(_fbb);
4648	builder_.add_rank(rank);
4649	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4650	builder_.add_fused_activation_function(fused_activation_function);
4651	return builder_.Finish();
4652	}
4653
4654	flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4655
4656	struct RNNOptionsT : public flatbuffers::NativeTable {
4657	typedef RNNOptions TableType;
4658	tflite::ActivationFunctionType fused_activation_function;
4659	bool asymmetric_quantize_inputs;
4660	RNNOptionsT()
4661	: fused_activation_function(tflite::ActivationFunctionType_NONE),
4662	asymmetric_quantize_inputs(false) {
4663	}
4664	};
4665
4666	struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4667	typedef RNNOptionsT NativeTableType;
4668	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4669	VT_FUSED_ACTIVATION_FUNCTION = `4`,
4670	VT_ASYMMETRIC_QUANTIZE_INPUTS = `6`
4671	};
4672	tflite::ActivationFunctionType fused_activation_function() const {
4673	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4674	}
4675	bool asymmetric_quantize_inputs() const {
4676	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
4677	}
4678	bool Verify(flatbuffers::Verifier &verifier) const {
4679	return VerifyTableStart(verifier) &&
4680	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4681	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4682	verifier.EndTable();
4683	}
4684	RNNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4685	void UnPackTo(RNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4686	static flatbuffers::Offset<RNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4687	};
4688
4689	struct RNNOptionsBuilder {
4690	flatbuffers::FlatBufferBuilder &fbb_;
4691	flatbuffers::uoffset_t start_;
4692	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4693	fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4694	}
4695	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4696	fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
4697	}
4698	explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4699	: fbb_(_fbb) {
4700	start_ = fbb_.StartTable();
4701	}
4702	RNNOptionsBuilder &operator=(const RNNOptionsBuilder &);
4703	flatbuffers::Offset<RNNOptions> Finish() {
4704	const auto end = fbb_.EndTable(start_);
4705	auto o = flatbuffers::Offset<RNNOptions>(end);
4706	return o;
4707	}
4708	};
4709
4710	inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
4711	flatbuffers::FlatBufferBuilder &_fbb,
4712	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4713	bool asymmetric_quantize_inputs = false) {
4714	RNNOptionsBuilder builder_(_fbb);
4715	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4716	builder_.add_fused_activation_function(fused_activation_function);
4717	return builder_.Finish();
4718	}
4719
4720	flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4721
4722	struct SequenceRNNOptionsT : public flatbuffers::NativeTable {
4723	typedef SequenceRNNOptions TableType;
4724	bool time_major;
4725	tflite::ActivationFunctionType fused_activation_function;
4726	bool asymmetric_quantize_inputs;
4727	SequenceRNNOptionsT()
4728	: time_major(false),
4729	fused_activation_function(tflite::ActivationFunctionType_NONE),
4730	asymmetric_quantize_inputs(false) {
4731	}
4732	};
4733
4734	struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4735	typedef SequenceRNNOptionsT NativeTableType;
4736	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4737	VT_TIME_MAJOR = `4`,
4738	VT_FUSED_ACTIVATION_FUNCTION = `6`,
4739	VT_ASYMMETRIC_QUANTIZE_INPUTS = `8`
4740	};
4741	bool time_major() const {
4742	return GetField<uint8_t>(VT_TIME_MAJOR, `0`) != `0`;
4743	}
4744	tflite::ActivationFunctionType fused_activation_function() const {
4745	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4746	}
4747	bool asymmetric_quantize_inputs() const {
4748	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
4749	}
4750	bool Verify(flatbuffers::Verifier &verifier) const {
4751	return VerifyTableStart(verifier) &&
4752	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4753	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4754	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4755	verifier.EndTable();
4756	}
4757	SequenceRNNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4758	void UnPackTo(SequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4759	static flatbuffers::Offset<SequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4760	};
4761
4762	struct SequenceRNNOptionsBuilder {
4763	flatbuffers::FlatBufferBuilder &fbb_;
4764	flatbuffers::uoffset_t start_;
4765	void add_time_major(bool time_major) {
4766	fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `0`);
4767	}
4768	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4769	fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4770	}
4771	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4772	fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
4773	}
4774	explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4775	: fbb_(_fbb) {
4776	start_ = fbb_.StartTable();
4777	}
4778	SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &);
4779	flatbuffers::Offset<SequenceRNNOptions> Finish() {
4780	const auto end = fbb_.EndTable(start_);
4781	auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
4782	return o;
4783	}
4784	};
4785
4786	inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
4787	flatbuffers::FlatBufferBuilder &_fbb,
4788	bool time_major = false,
4789	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4790	bool asymmetric_quantize_inputs = false) {
4791	SequenceRNNOptionsBuilder builder_(_fbb);
4792	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4793	builder_.add_fused_activation_function(fused_activation_function);
4794	builder_.add_time_major(time_major);
4795	return builder_.Finish();
4796	}
4797
4798	flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4799
4800	struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable {
4801	typedef BidirectionalSequenceRNNOptions TableType;
4802	bool time_major;
4803	tflite::ActivationFunctionType fused_activation_function;
4804	bool merge_outputs;
4805	bool asymmetric_quantize_inputs;
4806	BidirectionalSequenceRNNOptionsT()
4807	: time_major(false),
4808	fused_activation_function(tflite::ActivationFunctionType_NONE),
4809	merge_outputs(false),
4810	asymmetric_quantize_inputs(false) {
4811	}
4812	};
4813
4814	struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4815	typedef BidirectionalSequenceRNNOptionsT NativeTableType;
4816	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4817	VT_TIME_MAJOR = `4`,
4818	VT_FUSED_ACTIVATION_FUNCTION = `6`,
4819	VT_MERGE_OUTPUTS = `8`,
4820	VT_ASYMMETRIC_QUANTIZE_INPUTS = `10`
4821	};
4822	bool time_major() const {
4823	return GetField<uint8_t>(VT_TIME_MAJOR, `0`) != `0`;
4824	}
4825	tflite::ActivationFunctionType fused_activation_function() const {
4826	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4827	}
4828	bool merge_outputs() const {
4829	return GetField<uint8_t>(VT_MERGE_OUTPUTS, `0`) != `0`;
4830	}
4831	bool asymmetric_quantize_inputs() const {
4832	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
4833	}
4834	bool Verify(flatbuffers::Verifier &verifier) const {
4835	return VerifyTableStart(verifier) &&
4836	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4837	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4838	VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
4839	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4840	verifier.EndTable();
4841	}
4842	BidirectionalSequenceRNNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4843	void UnPackTo(BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4844	static flatbuffers::Offset<BidirectionalSequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4845	};
4846
4847	struct BidirectionalSequenceRNNOptionsBuilder {
4848	flatbuffers::FlatBufferBuilder &fbb_;
4849	flatbuffers::uoffset_t start_;
4850	void add_time_major(bool time_major) {
4851	fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `0`);
4852	}
4853	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4854	fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4855	}
4856	void add_merge_outputs(bool merge_outputs) {
4857	fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), `0`);
4858	}
4859	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4860	fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
4861	}
4862	explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4863	: fbb_(_fbb) {
4864	start_ = fbb_.StartTable();
4865	}
4866	BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &);
4867	flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
4868	const auto end = fbb_.EndTable(start_);
4869	auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
4870	return o;
4871	}
4872	};
4873
4874	inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
4875	flatbuffers::FlatBufferBuilder &_fbb,
4876	bool time_major = false,
4877	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4878	bool merge_outputs = false,
4879	bool asymmetric_quantize_inputs = false) {
4880	BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
4881	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4882	builder_.add_merge_outputs(merge_outputs);
4883	builder_.add_fused_activation_function(fused_activation_function);
4884	builder_.add_time_major(time_major);
4885	return builder_.Finish();
4886	}
4887
4888	flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4889
4890	struct FullyConnectedOptionsT : public flatbuffers::NativeTable {
4891	typedef FullyConnectedOptions TableType;
4892	tflite::ActivationFunctionType fused_activation_function;
4893	tflite::FullyConnectedOptionsWeightsFormat weights_format;
4894	bool keep_num_dims;
4895	bool asymmetric_quantize_inputs;
4896	FullyConnectedOptionsT()
4897	: fused_activation_function(tflite::ActivationFunctionType_NONE),
4898	weights_format(tflite::FullyConnectedOptionsWeightsFormat_DEFAULT),
4899	keep_num_dims(false),
4900	asymmetric_quantize_inputs(false) {
4901	}
4902	};
4903
4904	struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4905	typedef FullyConnectedOptionsT NativeTableType;
4906	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4907	VT_FUSED_ACTIVATION_FUNCTION = `4`,
4908	VT_WEIGHTS_FORMAT = `6`,
4909	VT_KEEP_NUM_DIMS = `8`,
4910	VT_ASYMMETRIC_QUANTIZE_INPUTS = `10`
4911	};
4912	tflite::ActivationFunctionType fused_activation_function() const {
4913	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
4914	}
4915	tflite::FullyConnectedOptionsWeightsFormat weights_format() const {
4916	return static_cast<tflite::FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, `0`));
4917	}
4918	bool keep_num_dims() const {
4919	return GetField<uint8_t>(VT_KEEP_NUM_DIMS, `0`) != `0`;
4920	}
4921	bool asymmetric_quantize_inputs() const {
4922	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
4923	}
4924	bool Verify(flatbuffers::Verifier &verifier) const {
4925	return VerifyTableStart(verifier) &&
4926	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4927	VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
4928	VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
4929	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
4930	verifier.EndTable();
4931	}
4932	FullyConnectedOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4933	void UnPackTo(FullyConnectedOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4934	static flatbuffers::Offset<FullyConnectedOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4935	};
4936
4937	struct FullyConnectedOptionsBuilder {
4938	flatbuffers::FlatBufferBuilder &fbb_;
4939	flatbuffers::uoffset_t start_;
4940	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
4941	fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
4942	}
4943	void add_weights_format(tflite::FullyConnectedOptionsWeightsFormat weights_format) {
4944	fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), `0`);
4945	}
4946	void add_keep_num_dims(bool keep_num_dims) {
4947	fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS, static_cast<uint8_t>(keep_num_dims), `0`);
4948	}
4949	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
4950	fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
4951	}
4952	explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4953	: fbb_(_fbb) {
4954	start_ = fbb_.StartTable();
4955	}
4956	FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &);
4957	flatbuffers::Offset<FullyConnectedOptions> Finish() {
4958	const auto end = fbb_.EndTable(start_);
4959	auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
4960	return o;
4961	}
4962	};
4963
4964	inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
4965	flatbuffers::FlatBufferBuilder &_fbb,
4966	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
4967	tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat_DEFAULT,
4968	bool keep_num_dims = false,
4969	bool asymmetric_quantize_inputs = false) {
4970	FullyConnectedOptionsBuilder builder_(_fbb);
4971	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4972	builder_.add_keep_num_dims(keep_num_dims);
4973	builder_.add_weights_format(weights_format);
4974	builder_.add_fused_activation_function(fused_activation_function);
4975	return builder_.Finish();
4976	}
4977
4978	flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4979
4980	struct SoftmaxOptionsT : public flatbuffers::NativeTable {
4981	typedef SoftmaxOptions TableType;
4982	float beta;
4983	SoftmaxOptionsT()
4984	: beta(`0.0f`) {
4985	}
4986	};
4987
4988	struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4989	typedef SoftmaxOptionsT NativeTableType;
4990	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4991	VT_BETA = `4`
4992	};
4993	float beta() const {
4994	return GetField<float>(VT_BETA, `0.0f`);
4995	}
4996	bool Verify(flatbuffers::Verifier &verifier) const {
4997	return VerifyTableStart(verifier) &&
4998	VerifyField<float>(verifier, VT_BETA) &&
4999	verifier.EndTable();
5000	}
5001	SoftmaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5002	void UnPackTo(SoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5003	static flatbuffers::Offset<SoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5004	};
5005
5006	struct SoftmaxOptionsBuilder {
5007	flatbuffers::FlatBufferBuilder &fbb_;
5008	flatbuffers::uoffset_t start_;
5009	void add_beta(float beta) {
5010	fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, `0.0f`);
5011	}
5012	explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5013	: fbb_(_fbb) {
5014	start_ = fbb_.StartTable();
5015	}
5016	SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &);
5017	flatbuffers::Offset<SoftmaxOptions> Finish() {
5018	const auto end = fbb_.EndTable(start_);
5019	auto o = flatbuffers::Offset<SoftmaxOptions>(end);
5020	return o;
5021	}
5022	};
5023
5024	inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
5025	flatbuffers::FlatBufferBuilder &_fbb,
5026	float beta = `0.0f`) {
5027	SoftmaxOptionsBuilder builder_(_fbb);
5028	builder_.add_beta(beta);
5029	return builder_.Finish();
5030	}
5031
5032	flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5033
5034	struct ConcatenationOptionsT : public flatbuffers::NativeTable {
5035	typedef ConcatenationOptions TableType;
5036	int32_t axis;
5037	tflite::ActivationFunctionType fused_activation_function;
5038	ConcatenationOptionsT()
5039	: axis(`0`),
5040	fused_activation_function(tflite::ActivationFunctionType_NONE) {
5041	}
5042	};
5043
5044	struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5045	typedef ConcatenationOptionsT NativeTableType;
5046	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5047	VT_AXIS = `4`,
5048	VT_FUSED_ACTIVATION_FUNCTION = `6`
5049	};
5050	int32_t axis() const {
5051	return GetField<int32_t>(VT_AXIS, `0`);
5052	}
5053	tflite::ActivationFunctionType fused_activation_function() const {
5054	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5055	}
5056	bool Verify(flatbuffers::Verifier &verifier) const {
5057	return VerifyTableStart(verifier) &&
5058	VerifyField<int32_t>(verifier, VT_AXIS) &&
5059	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5060	verifier.EndTable();
5061	}
5062	ConcatenationOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5063	void UnPackTo(ConcatenationOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5064	static flatbuffers::Offset<ConcatenationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5065	};
5066
5067	struct ConcatenationOptionsBuilder {
5068	flatbuffers::FlatBufferBuilder &fbb_;
5069	flatbuffers::uoffset_t start_;
5070	void add_axis(int32_t axis) {
5071	fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, `0`);
5072	}
5073	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5074	fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5075	}
5076	explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5077	: fbb_(_fbb) {
5078	start_ = fbb_.StartTable();
5079	}
5080	ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &);
5081	flatbuffers::Offset<ConcatenationOptions> Finish() {
5082	const auto end = fbb_.EndTable(start_);
5083	auto o = flatbuffers::Offset<ConcatenationOptions>(end);
5084	return o;
5085	}
5086	};
5087
5088	inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
5089	flatbuffers::FlatBufferBuilder &_fbb,
5090	int32_t axis = `0`,
5091	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5092	ConcatenationOptionsBuilder builder_(_fbb);
5093	builder_.add_axis(axis);
5094	builder_.add_fused_activation_function(fused_activation_function);
5095	return builder_.Finish();
5096	}
5097
5098	flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5099
5100	struct AddOptionsT : public flatbuffers::NativeTable {
5101	typedef AddOptions TableType;
5102	tflite::ActivationFunctionType fused_activation_function;
5103	bool pot_scale_int16;
5104	AddOptionsT()
5105	: fused_activation_function(tflite::ActivationFunctionType_NONE),
5106	pot_scale_int16(true) {
5107	}
5108	};
5109
5110	struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5111	typedef AddOptionsT NativeTableType;
5112	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5113	VT_FUSED_ACTIVATION_FUNCTION = `4`,
5114	VT_POT_SCALE_INT16 = `6`
5115	};
5116	tflite::ActivationFunctionType fused_activation_function() const {
5117	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5118	}
5119	bool pot_scale_int16() const {
5120	return GetField<uint8_t>(VT_POT_SCALE_INT16, `1`) != `0`;
5121	}
5122	bool Verify(flatbuffers::Verifier &verifier) const {
5123	return VerifyTableStart(verifier) &&
5124	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5125	VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) &&
5126	verifier.EndTable();
5127	}
5128	AddOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5129	void UnPackTo(AddOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5130	static flatbuffers::Offset<AddOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5131	};
5132
5133	struct AddOptionsBuilder {
5134	flatbuffers::FlatBufferBuilder &fbb_;
5135	flatbuffers::uoffset_t start_;
5136	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5137	fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5138	}
5139	void add_pot_scale_int16(bool pot_scale_int16) {
5140	fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), `1`);
5141	}
5142	explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5143	: fbb_(_fbb) {
5144	start_ = fbb_.StartTable();
5145	}
5146	AddOptionsBuilder &operator=(const AddOptionsBuilder &);
5147	flatbuffers::Offset<AddOptions> Finish() {
5148	const auto end = fbb_.EndTable(start_);
5149	auto o = flatbuffers::Offset<AddOptions>(end);
5150	return o;
5151	}
5152	};
5153
5154	inline flatbuffers::Offset<AddOptions> CreateAddOptions(
5155	flatbuffers::FlatBufferBuilder &_fbb,
5156	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5157	bool pot_scale_int16 = true) {
5158	AddOptionsBuilder builder_(_fbb);
5159	builder_.add_pot_scale_int16(pot_scale_int16);
5160	builder_.add_fused_activation_function(fused_activation_function);
5161	return builder_.Finish();
5162	}
5163
5164	flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5165
5166	struct MulOptionsT : public flatbuffers::NativeTable {
5167	typedef MulOptions TableType;
5168	tflite::ActivationFunctionType fused_activation_function;
5169	MulOptionsT()
5170	: fused_activation_function(tflite::ActivationFunctionType_NONE) {
5171	}
5172	};
5173
5174	struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5175	typedef MulOptionsT NativeTableType;
5176	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5177	VT_FUSED_ACTIVATION_FUNCTION = `4`
5178	};
5179	tflite::ActivationFunctionType fused_activation_function() const {
5180	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5181	}
5182	bool Verify(flatbuffers::Verifier &verifier) const {
5183	return VerifyTableStart(verifier) &&
5184	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5185	verifier.EndTable();
5186	}
5187	MulOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5188	void UnPackTo(MulOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5189	static flatbuffers::Offset<MulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5190	};
5191
5192	struct MulOptionsBuilder {
5193	flatbuffers::FlatBufferBuilder &fbb_;
5194	flatbuffers::uoffset_t start_;
5195	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5196	fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5197	}
5198	explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5199	: fbb_(_fbb) {
5200	start_ = fbb_.StartTable();
5201	}
5202	MulOptionsBuilder &operator=(const MulOptionsBuilder &);
5203	flatbuffers::Offset<MulOptions> Finish() {
5204	const auto end = fbb_.EndTable(start_);
5205	auto o = flatbuffers::Offset<MulOptions>(end);
5206	return o;
5207	}
5208	};
5209
5210	inline flatbuffers::Offset<MulOptions> CreateMulOptions(
5211	flatbuffers::FlatBufferBuilder &_fbb,
5212	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5213	MulOptionsBuilder builder_(_fbb);
5214	builder_.add_fused_activation_function(fused_activation_function);
5215	return builder_.Finish();
5216	}
5217
5218	flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5219
5220	struct L2NormOptionsT : public flatbuffers::NativeTable {
5221	typedef L2NormOptions TableType;
5222	tflite::ActivationFunctionType fused_activation_function;
5223	L2NormOptionsT()
5224	: fused_activation_function(tflite::ActivationFunctionType_NONE) {
5225	}
5226	};
5227
5228	struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5229	typedef L2NormOptionsT NativeTableType;
5230	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5231	VT_FUSED_ACTIVATION_FUNCTION = `4`
5232	};
5233	tflite::ActivationFunctionType fused_activation_function() const {
5234	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5235	}
5236	bool Verify(flatbuffers::Verifier &verifier) const {
5237	return VerifyTableStart(verifier) &&
5238	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5239	verifier.EndTable();
5240	}
5241	L2NormOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5242	void UnPackTo(L2NormOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5243	static flatbuffers::Offset<L2NormOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5244	};
5245
5246	struct L2NormOptionsBuilder {
5247	flatbuffers::FlatBufferBuilder &fbb_;
5248	flatbuffers::uoffset_t start_;
5249	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5250	fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5251	}
5252	explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5253	: fbb_(_fbb) {
5254	start_ = fbb_.StartTable();
5255	}
5256	L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &);
5257	flatbuffers::Offset<L2NormOptions> Finish() {
5258	const auto end = fbb_.EndTable(start_);
5259	auto o = flatbuffers::Offset<L2NormOptions>(end);
5260	return o;
5261	}
5262	};
5263
5264	inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
5265	flatbuffers::FlatBufferBuilder &_fbb,
5266	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5267	L2NormOptionsBuilder builder_(_fbb);
5268	builder_.add_fused_activation_function(fused_activation_function);
5269	return builder_.Finish();
5270	}
5271
5272	flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5273
5274	struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable {
5275	typedef LocalResponseNormalizationOptions TableType;
5276	int32_t radius;
5277	float bias;
5278	float alpha;
5279	float beta;
5280	LocalResponseNormalizationOptionsT()
5281	: radius(`0`),
5282	bias(`0.0f`),
5283	alpha(`0.0f`),
5284	beta(`0.0f`) {
5285	}
5286	};
5287
5288	struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5289	typedef LocalResponseNormalizationOptionsT NativeTableType;
5290	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5291	VT_RADIUS = `4`,
5292	VT_BIAS = `6`,
5293	VT_ALPHA = `8`,
5294	VT_BETA = `10`
5295	};
5296	int32_t radius() const {
5297	return GetField<int32_t>(VT_RADIUS, `0`);
5298	}
5299	float bias() const {
5300	return GetField<float>(VT_BIAS, `0.0f`);
5301	}
5302	float alpha() const {
5303	return GetField<float>(VT_ALPHA, `0.0f`);
5304	}
5305	float beta() const {
5306	return GetField<float>(VT_BETA, `0.0f`);
5307	}
5308	bool Verify(flatbuffers::Verifier &verifier) const {
5309	return VerifyTableStart(verifier) &&
5310	VerifyField<int32_t>(verifier, VT_RADIUS) &&
5311	VerifyField<float>(verifier, VT_BIAS) &&
5312	VerifyField<float>(verifier, VT_ALPHA) &&
5313	VerifyField<float>(verifier, VT_BETA) &&
5314	verifier.EndTable();
5315	}
5316	LocalResponseNormalizationOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5317	void UnPackTo(LocalResponseNormalizationOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5318	static flatbuffers::Offset<LocalResponseNormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5319	};
5320
5321	struct LocalResponseNormalizationOptionsBuilder {
5322	flatbuffers::FlatBufferBuilder &fbb_;
5323	flatbuffers::uoffset_t start_;
5324	void add_radius(int32_t radius) {
5325	fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, `0`);
5326	}
5327	void add_bias(float bias) {
5328	fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, `0.0f`);
5329	}
5330	void add_alpha(float alpha) {
5331	fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, `0.0f`);
5332	}
5333	void add_beta(float beta) {
5334	fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, `0.0f`);
5335	}
5336	explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5337	: fbb_(_fbb) {
5338	start_ = fbb_.StartTable();
5339	}
5340	LocalResponseNormalizationOptionsBuilder &operator=(const LocalResponseNormalizationOptionsBuilder &);
5341	flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
5342	const auto end = fbb_.EndTable(start_);
5343	auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
5344	return o;
5345	}
5346	};
5347
5348	inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
5349	flatbuffers::FlatBufferBuilder &_fbb,
5350	int32_t radius = `0`,
5351	float bias = `0.0f`,
5352	float alpha = `0.0f`,
5353	float beta = `0.0f`) {
5354	LocalResponseNormalizationOptionsBuilder builder_(_fbb);
5355	builder_.add_beta(beta);
5356	builder_.add_alpha(alpha);
5357	builder_.add_bias(bias);
5358	builder_.add_radius(radius);
5359	return builder_.Finish();
5360	}
5361
5362	flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5363
5364	struct LSTMOptionsT : public flatbuffers::NativeTable {
5365	typedef LSTMOptions TableType;
5366	tflite::ActivationFunctionType fused_activation_function;
5367	float cell_clip;
5368	float proj_clip;
5369	tflite::LSTMKernelType kernel_type;
5370	bool asymmetric_quantize_inputs;
5371	LSTMOptionsT()
5372	: fused_activation_function(tflite::ActivationFunctionType_NONE),
5373	cell_clip(`0.0f`),
5374	proj_clip(`0.0f`),
5375	kernel_type(tflite::LSTMKernelType_FULL),
5376	asymmetric_quantize_inputs(false) {
5377	}
5378	};
5379
5380	struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5381	typedef LSTMOptionsT NativeTableType;
5382	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5383	VT_FUSED_ACTIVATION_FUNCTION = `4`,
5384	VT_CELL_CLIP = `6`,
5385	VT_PROJ_CLIP = `8`,
5386	VT_KERNEL_TYPE = `10`,
5387	VT_ASYMMETRIC_QUANTIZE_INPUTS = `12`
5388	};
5389	tflite::ActivationFunctionType fused_activation_function() const {
5390	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5391	}
5392	float cell_clip() const {
5393	return GetField<float>(VT_CELL_CLIP, `0.0f`);
5394	}
5395	float proj_clip() const {
5396	return GetField<float>(VT_PROJ_CLIP, `0.0f`);
5397	}
5398	tflite::LSTMKernelType kernel_type() const {
5399	return static_cast<tflite::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, `0`));
5400	}
5401	bool asymmetric_quantize_inputs() const {
5402	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5403	}
5404	bool Verify(flatbuffers::Verifier &verifier) const {
5405	return VerifyTableStart(verifier) &&
5406	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5407	VerifyField<float>(verifier, VT_CELL_CLIP) &&
5408	VerifyField<float>(verifier, VT_PROJ_CLIP) &&
5409	VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
5410	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
5411	verifier.EndTable();
5412	}
5413	LSTMOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5414	void UnPackTo(LSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5415	static flatbuffers::Offset<LSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5416	};
5417
5418	struct LSTMOptionsBuilder {
5419	flatbuffers::FlatBufferBuilder &fbb_;
5420	flatbuffers::uoffset_t start_;
5421	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5422	fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5423	}
5424	void add_cell_clip(float cell_clip) {
5425	fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, `0.0f`);
5426	}
5427	void add_proj_clip(float proj_clip) {
5428	fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, `0.0f`);
5429	}
5430	void add_kernel_type(tflite::LSTMKernelType kernel_type) {
5431	fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), `0`);
5432	}
5433	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5434	fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5435	}
5436	explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5437	: fbb_(_fbb) {
5438	start_ = fbb_.StartTable();
5439	}
5440	LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &);
5441	flatbuffers::Offset<LSTMOptions> Finish() {
5442	const auto end = fbb_.EndTable(start_);
5443	auto o = flatbuffers::Offset<LSTMOptions>(end);
5444	return o;
5445	}
5446	};
5447
5448	inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
5449	flatbuffers::FlatBufferBuilder &_fbb,
5450	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5451	float cell_clip = `0.0f`,
5452	float proj_clip = `0.0f`,
5453	tflite::LSTMKernelType kernel_type = tflite::LSTMKernelType_FULL,
5454	bool asymmetric_quantize_inputs = false) {
5455	LSTMOptionsBuilder builder_(_fbb);
5456	builder_.add_proj_clip(proj_clip);
5457	builder_.add_cell_clip(cell_clip);
5458	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5459	builder_.add_kernel_type(kernel_type);
5460	builder_.add_fused_activation_function(fused_activation_function);
5461	return builder_.Finish();
5462	}
5463
5464	flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5465
5466	struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
5467	typedef UnidirectionalSequenceLSTMOptions TableType;
5468	tflite::ActivationFunctionType fused_activation_function;
5469	float cell_clip;
5470	float proj_clip;
5471	bool time_major;
5472	bool asymmetric_quantize_inputs;
5473	UnidirectionalSequenceLSTMOptionsT()
5474	: fused_activation_function(tflite::ActivationFunctionType_NONE),
5475	cell_clip(`0.0f`),
5476	proj_clip(`0.0f`),
5477	time_major(false),
5478	asymmetric_quantize_inputs(false) {
5479	}
5480	};
5481
5482	struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5483	typedef UnidirectionalSequenceLSTMOptionsT NativeTableType;
5484	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5485	VT_FUSED_ACTIVATION_FUNCTION = `4`,
5486	VT_CELL_CLIP = `6`,
5487	VT_PROJ_CLIP = `8`,
5488	VT_TIME_MAJOR = `10`,
5489	VT_ASYMMETRIC_QUANTIZE_INPUTS = `12`
5490	};
5491	tflite::ActivationFunctionType fused_activation_function() const {
5492	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5493	}
5494	float cell_clip() const {
5495	return GetField<float>(VT_CELL_CLIP, `0.0f`);
5496	}
5497	float proj_clip() const {
5498	return GetField<float>(VT_PROJ_CLIP, `0.0f`);
5499	}
5500	bool time_major() const {
5501	return GetField<uint8_t>(VT_TIME_MAJOR, `0`) != `0`;
5502	}
5503	bool asymmetric_quantize_inputs() const {
5504	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5505	}
5506	bool Verify(flatbuffers::Verifier &verifier) const {
5507	return VerifyTableStart(verifier) &&
5508	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5509	VerifyField<float>(verifier, VT_CELL_CLIP) &&
5510	VerifyField<float>(verifier, VT_PROJ_CLIP) &&
5511	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
5512	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
5513	verifier.EndTable();
5514	}
5515	UnidirectionalSequenceLSTMOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5516	void UnPackTo(UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5517	static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5518	};
5519
5520	struct UnidirectionalSequenceLSTMOptionsBuilder {
5521	flatbuffers::FlatBufferBuilder &fbb_;
5522	flatbuffers::uoffset_t start_;
5523	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5524	fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5525	}
5526	void add_cell_clip(float cell_clip) {
5527	fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, `0.0f`);
5528	}
5529	void add_proj_clip(float proj_clip) {
5530	fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, `0.0f`);
5531	}
5532	void add_time_major(bool time_major) {
5533	fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `0`);
5534	}
5535	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5536	fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5537	}
5538	explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5539	: fbb_(_fbb) {
5540	start_ = fbb_.StartTable();
5541	}
5542	UnidirectionalSequenceLSTMOptionsBuilder &operator=(const UnidirectionalSequenceLSTMOptionsBuilder &);
5543	flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
5544	const auto end = fbb_.EndTable(start_);
5545	auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
5546	return o;
5547	}
5548	};
5549
5550	inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
5551	flatbuffers::FlatBufferBuilder &_fbb,
5552	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5553	float cell_clip = `0.0f`,
5554	float proj_clip = `0.0f`,
5555	bool time_major = false,
5556	bool asymmetric_quantize_inputs = false) {
5557	UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
5558	builder_.add_proj_clip(proj_clip);
5559	builder_.add_cell_clip(cell_clip);
5560	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5561	builder_.add_time_major(time_major);
5562	builder_.add_fused_activation_function(fused_activation_function);
5563	return builder_.Finish();
5564	}
5565
5566	flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5567
5568	struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
5569	typedef BidirectionalSequenceLSTMOptions TableType;
5570	tflite::ActivationFunctionType fused_activation_function;
5571	float cell_clip;
5572	float proj_clip;
5573	bool merge_outputs;
5574	bool time_major;
5575	bool asymmetric_quantize_inputs;
5576	BidirectionalSequenceLSTMOptionsT()
5577	: fused_activation_function(tflite::ActivationFunctionType_NONE),
5578	cell_clip(`0.0f`),
5579	proj_clip(`0.0f`),
5580	merge_outputs(false),
5581	time_major(true),
5582	asymmetric_quantize_inputs(false) {
5583	}
5584	};
5585
5586	struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5587	typedef BidirectionalSequenceLSTMOptionsT NativeTableType;
5588	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5589	VT_FUSED_ACTIVATION_FUNCTION = `4`,
5590	VT_CELL_CLIP = `6`,
5591	VT_PROJ_CLIP = `8`,
5592	VT_MERGE_OUTPUTS = `10`,
5593	VT_TIME_MAJOR = `12`,
5594	VT_ASYMMETRIC_QUANTIZE_INPUTS = `14`
5595	};
5596	tflite::ActivationFunctionType fused_activation_function() const {
5597	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5598	}
5599	float cell_clip() const {
5600	return GetField<float>(VT_CELL_CLIP, `0.0f`);
5601	}
5602	float proj_clip() const {
5603	return GetField<float>(VT_PROJ_CLIP, `0.0f`);
5604	}
5605	bool merge_outputs() const {
5606	return GetField<uint8_t>(VT_MERGE_OUTPUTS, `0`) != `0`;
5607	}
5608	bool time_major() const {
5609	return GetField<uint8_t>(VT_TIME_MAJOR, `1`) != `0`;
5610	}
5611	bool asymmetric_quantize_inputs() const {
5612	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5613	}
5614	bool Verify(flatbuffers::Verifier &verifier) const {
5615	return VerifyTableStart(verifier) &&
5616	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5617	VerifyField<float>(verifier, VT_CELL_CLIP) &&
5618	VerifyField<float>(verifier, VT_PROJ_CLIP) &&
5619	VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
5620	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
5621	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
5622	verifier.EndTable();
5623	}
5624	BidirectionalSequenceLSTMOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5625	void UnPackTo(BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5626	static flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5627	};
5628
5629	struct BidirectionalSequenceLSTMOptionsBuilder {
5630	flatbuffers::FlatBufferBuilder &fbb_;
5631	flatbuffers::uoffset_t start_;
5632	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5633	fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5634	}
5635	void add_cell_clip(float cell_clip) {
5636	fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, `0.0f`);
5637	}
5638	void add_proj_clip(float proj_clip) {
5639	fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, `0.0f`);
5640	}
5641	void add_merge_outputs(bool merge_outputs) {
5642	fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), `0`);
5643	}
5644	void add_time_major(bool time_major) {
5645	fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `1`);
5646	}
5647	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5648	fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5649	}
5650	explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5651	: fbb_(_fbb) {
5652	start_ = fbb_.StartTable();
5653	}
5654	BidirectionalSequenceLSTMOptionsBuilder &operator=(const BidirectionalSequenceLSTMOptionsBuilder &);
5655	flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
5656	const auto end = fbb_.EndTable(start_);
5657	auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
5658	return o;
5659	}
5660	};
5661
5662	inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
5663	flatbuffers::FlatBufferBuilder &_fbb,
5664	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5665	float cell_clip = `0.0f`,
5666	float proj_clip = `0.0f`,
5667	bool merge_outputs = false,
5668	bool time_major = true,
5669	bool asymmetric_quantize_inputs = false) {
5670	BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
5671	builder_.add_proj_clip(proj_clip);
5672	builder_.add_cell_clip(cell_clip);
5673	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5674	builder_.add_time_major(time_major);
5675	builder_.add_merge_outputs(merge_outputs);
5676	builder_.add_fused_activation_function(fused_activation_function);
5677	return builder_.Finish();
5678	}
5679
5680	flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5681
5682	struct ResizeBilinearOptionsT : public flatbuffers::NativeTable {
5683	typedef ResizeBilinearOptions TableType;
5684	bool align_corners;
5685	bool half_pixel_centers;
5686	ResizeBilinearOptionsT()
5687	: align_corners(false),
5688	half_pixel_centers(false) {
5689	}
5690	};
5691
5692	struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5693	typedef ResizeBilinearOptionsT NativeTableType;
5694	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5695	VT_ALIGN_CORNERS = `8`,
5696	VT_HALF_PIXEL_CENTERS = `10`
5697	};
5698	bool align_corners() const {
5699	return GetField<uint8_t>(VT_ALIGN_CORNERS, `0`) != `0`;
5700	}
5701	bool half_pixel_centers() const {
5702	return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, `0`) != `0`;
5703	}
5704	bool Verify(flatbuffers::Verifier &verifier) const {
5705	return VerifyTableStart(verifier) &&
5706	VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
5707	VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) &&
5708	verifier.EndTable();
5709	}
5710	ResizeBilinearOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5711	void UnPackTo(ResizeBilinearOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5712	static flatbuffers::Offset<ResizeBilinearOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5713	};
5714
5715	struct ResizeBilinearOptionsBuilder {
5716	flatbuffers::FlatBufferBuilder &fbb_;
5717	flatbuffers::uoffset_t start_;
5718	void add_align_corners(bool align_corners) {
5719	fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), `0`);
5720	}
5721	void add_half_pixel_centers(bool half_pixel_centers) {
5722	fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), `0`);
5723	}
5724	explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5725	: fbb_(_fbb) {
5726	start_ = fbb_.StartTable();
5727	}
5728	ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &);
5729	flatbuffers::Offset<ResizeBilinearOptions> Finish() {
5730	const auto end = fbb_.EndTable(start_);
5731	auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
5732	return o;
5733	}
5734	};
5735
5736	inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
5737	flatbuffers::FlatBufferBuilder &_fbb,
5738	bool align_corners = false,
5739	bool half_pixel_centers = false) {
5740	ResizeBilinearOptionsBuilder builder_(_fbb);
5741	builder_.add_half_pixel_centers(half_pixel_centers);
5742	builder_.add_align_corners(align_corners);
5743	return builder_.Finish();
5744	}
5745
5746	flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5747
5748	struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable {
5749	typedef ResizeNearestNeighborOptions TableType;
5750	bool align_corners;
5751	bool half_pixel_centers;
5752	ResizeNearestNeighborOptionsT()
5753	: align_corners(false),
5754	half_pixel_centers(false) {
5755	}
5756	};
5757
5758	struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5759	typedef ResizeNearestNeighborOptionsT NativeTableType;
5760	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5761	VT_ALIGN_CORNERS = `4`,
5762	VT_HALF_PIXEL_CENTERS = `6`
5763	};
5764	bool align_corners() const {
5765	return GetField<uint8_t>(VT_ALIGN_CORNERS, `0`) != `0`;
5766	}
5767	bool half_pixel_centers() const {
5768	return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, `0`) != `0`;
5769	}
5770	bool Verify(flatbuffers::Verifier &verifier) const {
5771	return VerifyTableStart(verifier) &&
5772	VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
5773	VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) &&
5774	verifier.EndTable();
5775	}
5776	ResizeNearestNeighborOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5777	void UnPackTo(ResizeNearestNeighborOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5778	static flatbuffers::Offset<ResizeNearestNeighborOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5779	};
5780
5781	struct ResizeNearestNeighborOptionsBuilder {
5782	flatbuffers::FlatBufferBuilder &fbb_;
5783	flatbuffers::uoffset_t start_;
5784	void add_align_corners(bool align_corners) {
5785	fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), `0`);
5786	}
5787	void add_half_pixel_centers(bool half_pixel_centers) {
5788	fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), `0`);
5789	}
5790	explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5791	: fbb_(_fbb) {
5792	start_ = fbb_.StartTable();
5793	}
5794	ResizeNearestNeighborOptionsBuilder &operator=(const ResizeNearestNeighborOptionsBuilder &);
5795	flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
5796	const auto end = fbb_.EndTable(start_);
5797	auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
5798	return o;
5799	}
5800	};
5801
5802	inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
5803	flatbuffers::FlatBufferBuilder &_fbb,
5804	bool align_corners = false,
5805	bool half_pixel_centers = false) {
5806	ResizeNearestNeighborOptionsBuilder builder_(_fbb);
5807	builder_.add_half_pixel_centers(half_pixel_centers);
5808	builder_.add_align_corners(align_corners);
5809	return builder_.Finish();
5810	}
5811
5812	flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5813
5814	struct CallOptionsT : public flatbuffers::NativeTable {
5815	typedef CallOptions TableType;
5816	uint32_t subgraph;
5817	CallOptionsT()
5818	: subgraph(`0`) {
5819	}
5820	};
5821
5822	struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5823	typedef CallOptionsT NativeTableType;
5824	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5825	VT_SUBGRAPH = `4`
5826	};
5827	uint32_t subgraph() const {
5828	return GetField<uint32_t>(VT_SUBGRAPH, `0`);
5829	}
5830	bool Verify(flatbuffers::Verifier &verifier) const {
5831	return VerifyTableStart(verifier) &&
5832	VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
5833	verifier.EndTable();
5834	}
5835	CallOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5836	void UnPackTo(CallOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5837	static flatbuffers::Offset<CallOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5838	};
5839
5840	struct CallOptionsBuilder {
5841	flatbuffers::FlatBufferBuilder &fbb_;
5842	flatbuffers::uoffset_t start_;
5843	void add_subgraph(uint32_t subgraph) {
5844	fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, `0`);
5845	}
5846	explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5847	: fbb_(_fbb) {
5848	start_ = fbb_.StartTable();
5849	}
5850	CallOptionsBuilder &operator=(const CallOptionsBuilder &);
5851	flatbuffers::Offset<CallOptions> Finish() {
5852	const auto end = fbb_.EndTable(start_);
5853	auto o = flatbuffers::Offset<CallOptions>(end);
5854	return o;
5855	}
5856	};
5857
5858	inline flatbuffers::Offset<CallOptions> CreateCallOptions(
5859	flatbuffers::FlatBufferBuilder &_fbb,
5860	uint32_t subgraph = `0`) {
5861	CallOptionsBuilder builder_(_fbb);
5862	builder_.add_subgraph(subgraph);
5863	return builder_.Finish();
5864	}
5865
5866	flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5867
5868	struct PadOptionsT : public flatbuffers::NativeTable {
5869	typedef PadOptions TableType;
5870	PadOptionsT() {
5871	}
5872	};
5873
5874	struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5875	typedef PadOptionsT NativeTableType;
5876	bool Verify(flatbuffers::Verifier &verifier) const {
5877	return VerifyTableStart(verifier) &&
5878	verifier.EndTable();
5879	}
5880	PadOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5881	void UnPackTo(PadOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5882	static flatbuffers::Offset<PadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5883	};
5884
5885	struct PadOptionsBuilder {
5886	flatbuffers::FlatBufferBuilder &fbb_;
5887	flatbuffers::uoffset_t start_;
5888	explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5889	: fbb_(_fbb) {
5890	start_ = fbb_.StartTable();
5891	}
5892	PadOptionsBuilder &operator=(const PadOptionsBuilder &);
5893	flatbuffers::Offset<PadOptions> Finish() {
5894	const auto end = fbb_.EndTable(start_);
5895	auto o = flatbuffers::Offset<PadOptions>(end);
5896	return o;
5897	}
5898	};
5899
5900	inline flatbuffers::Offset<PadOptions> CreatePadOptions(
5901	flatbuffers::FlatBufferBuilder &_fbb) {
5902	PadOptionsBuilder builder_(_fbb);
5903	return builder_.Finish();
5904	}
5905
5906	flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5907
5908	struct PadV2OptionsT : public flatbuffers::NativeTable {
5909	typedef PadV2Options TableType;
5910	PadV2OptionsT() {
5911	}
5912	};
5913
5914	struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5915	typedef PadV2OptionsT NativeTableType;
5916	bool Verify(flatbuffers::Verifier &verifier) const {
5917	return VerifyTableStart(verifier) &&
5918	verifier.EndTable();
5919	}
5920	PadV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5921	void UnPackTo(PadV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5922	static flatbuffers::Offset<PadV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5923	};
5924
5925	struct PadV2OptionsBuilder {
5926	flatbuffers::FlatBufferBuilder &fbb_;
5927	flatbuffers::uoffset_t start_;
5928	explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5929	: fbb_(_fbb) {
5930	start_ = fbb_.StartTable();
5931	}
5932	PadV2OptionsBuilder &operator=(const PadV2OptionsBuilder &);
5933	flatbuffers::Offset<PadV2Options> Finish() {
5934	const auto end = fbb_.EndTable(start_);
5935	auto o = flatbuffers::Offset<PadV2Options>(end);
5936	return o;
5937	}
5938	};
5939
5940	inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(
5941	flatbuffers::FlatBufferBuilder &_fbb) {
5942	PadV2OptionsBuilder builder_(_fbb);
5943	return builder_.Finish();
5944	}
5945
5946	flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5947
5948	struct ReshapeOptionsT : public flatbuffers::NativeTable {
5949	typedef ReshapeOptions TableType;
5950	std::vector<int32_t> new_shape;
5951	ReshapeOptionsT() {
5952	}
5953	};
5954
5955	struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5956	typedef ReshapeOptionsT NativeTableType;
5957	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5958	VT_NEW_SHAPE = `4`
5959	};
5960	const flatbuffers::Vector<int32_t> new_shape() const* {
5961	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
5962	}
5963	bool Verify(flatbuffers::Verifier &verifier) const {
5964	return VerifyTableStart(verifier) &&
5965	VerifyOffset(verifier, VT_NEW_SHAPE) &&
5966	verifier.VerifyVector(new_shape()) &&
5967	verifier.EndTable();
5968	}
5969	ReshapeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5970	void UnPackTo(ReshapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5971	static flatbuffers::Offset<ReshapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5972	};
5973
5974	struct ReshapeOptionsBuilder {
5975	flatbuffers::FlatBufferBuilder &fbb_;
5976	flatbuffers::uoffset_t start_;
5977	void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) {
5978	fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
5979	}
5980	explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5981	: fbb_(_fbb) {
5982	start_ = fbb_.StartTable();
5983	}
5984	ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &);
5985	flatbuffers::Offset<ReshapeOptions> Finish() {
5986	const auto end = fbb_.EndTable(start_);
5987	auto o = flatbuffers::Offset<ReshapeOptions>(end);
5988	return o;
5989	}
5990	};
5991
5992	inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
5993	flatbuffers::FlatBufferBuilder &_fbb,
5994	flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = `0`) {
5995	ReshapeOptionsBuilder builder_(_fbb);
5996	builder_.add_new_shape(new_shape);
5997	return builder_.Finish();
5998	}
5999
6000	inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
6001	flatbuffers::FlatBufferBuilder &_fbb,
6002	const std::vector<int32_t> new_shape = nullptr*) {
6003	auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : `0`;
6004	return tflite::CreateReshapeOptions(
6005	_fbb,
6006	new_shape__);
6007	}
6008
6009	flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6010
6011	struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable {
6012	typedef SpaceToBatchNDOptions TableType;
6013	SpaceToBatchNDOptionsT() {
6014	}
6015	};
6016
6017	struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6018	typedef SpaceToBatchNDOptionsT NativeTableType;
6019	bool Verify(flatbuffers::Verifier &verifier) const {
6020	return VerifyTableStart(verifier) &&
6021	verifier.EndTable();
6022	}
6023	SpaceToBatchNDOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6024	void UnPackTo(SpaceToBatchNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6025	static flatbuffers::Offset<SpaceToBatchNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6026	};
6027
6028	struct SpaceToBatchNDOptionsBuilder {
6029	flatbuffers::FlatBufferBuilder &fbb_;
6030	flatbuffers::uoffset_t start_;
6031	explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6032	: fbb_(_fbb) {
6033	start_ = fbb_.StartTable();
6034	}
6035	SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &);
6036	flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
6037	const auto end = fbb_.EndTable(start_);
6038	auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
6039	return o;
6040	}
6041	};
6042
6043	inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
6044	flatbuffers::FlatBufferBuilder &_fbb) {
6045	SpaceToBatchNDOptionsBuilder builder_(_fbb);
6046	return builder_.Finish();
6047	}
6048
6049	flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6050
6051	struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable {
6052	typedef BatchToSpaceNDOptions TableType;
6053	BatchToSpaceNDOptionsT() {
6054	}
6055	};
6056
6057	struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6058	typedef BatchToSpaceNDOptionsT NativeTableType;
6059	bool Verify(flatbuffers::Verifier &verifier) const {
6060	return VerifyTableStart(verifier) &&
6061	verifier.EndTable();
6062	}
6063	BatchToSpaceNDOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6064	void UnPackTo(BatchToSpaceNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6065	static flatbuffers::Offset<BatchToSpaceNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6066	};
6067
6068	struct BatchToSpaceNDOptionsBuilder {
6069	flatbuffers::FlatBufferBuilder &fbb_;
6070	flatbuffers::uoffset_t start_;
6071	explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6072	: fbb_(_fbb) {
6073	start_ = fbb_.StartTable();
6074	}
6075	BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &);
6076	flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
6077	const auto end = fbb_.EndTable(start_);
6078	auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
6079	return o;
6080	}
6081	};
6082
6083	inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
6084	flatbuffers::FlatBufferBuilder &_fbb) {
6085	BatchToSpaceNDOptionsBuilder builder_(_fbb);
6086	return builder_.Finish();
6087	}
6088
6089	flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6090
6091	struct SkipGramOptionsT : public flatbuffers::NativeTable {
6092	typedef SkipGramOptions TableType;
6093	int32_t ngram_size;
6094	int32_t max_skip_size;
6095	bool include_all_ngrams;
6096	SkipGramOptionsT()
6097	: ngram_size(`0`),
6098	max_skip_size(`0`),
6099	include_all_ngrams(false) {
6100	}
6101	};
6102
6103	struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6104	typedef SkipGramOptionsT NativeTableType;
6105	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6106	VT_NGRAM_SIZE = `4`,
6107	VT_MAX_SKIP_SIZE = `6`,
6108	VT_INCLUDE_ALL_NGRAMS = `8`
6109	};
6110	int32_t ngram_size() const {
6111	return GetField<int32_t>(VT_NGRAM_SIZE, `0`);
6112	}
6113	int32_t max_skip_size() const {
6114	return GetField<int32_t>(VT_MAX_SKIP_SIZE, `0`);
6115	}
6116	bool include_all_ngrams() const {
6117	return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, `0`) != `0`;
6118	}
6119	bool Verify(flatbuffers::Verifier &verifier) const {
6120	return VerifyTableStart(verifier) &&
6121	VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
6122	VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
6123	VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) &&
6124	verifier.EndTable();
6125	}
6126	SkipGramOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6127	void UnPackTo(SkipGramOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6128	static flatbuffers::Offset<SkipGramOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6129	};
6130
6131	struct SkipGramOptionsBuilder {
6132	flatbuffers::FlatBufferBuilder &fbb_;
6133	flatbuffers::uoffset_t start_;
6134	void add_ngram_size(int32_t ngram_size) {
6135	fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, `0`);
6136	}
6137	void add_max_skip_size(int32_t max_skip_size) {
6138	fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, `0`);
6139	}
6140	void add_include_all_ngrams(bool include_all_ngrams) {
6141	fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), `0`);
6142	}
6143	explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6144	: fbb_(_fbb) {
6145	start_ = fbb_.StartTable();
6146	}
6147	SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &);
6148	flatbuffers::Offset<SkipGramOptions> Finish() {
6149	const auto end = fbb_.EndTable(start_);
6150	auto o = flatbuffers::Offset<SkipGramOptions>(end);
6151	return o;
6152	}
6153	};
6154
6155	inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
6156	flatbuffers::FlatBufferBuilder &_fbb,
6157	int32_t ngram_size = `0`,
6158	int32_t max_skip_size = `0`,
6159	bool include_all_ngrams = false) {
6160	SkipGramOptionsBuilder builder_(_fbb);
6161	builder_.add_max_skip_size(max_skip_size);
6162	builder_.add_ngram_size(ngram_size);
6163	builder_.add_include_all_ngrams(include_all_ngrams);
6164	return builder_.Finish();
6165	}
6166
6167	flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6168
6169	struct SpaceToDepthOptionsT : public flatbuffers::NativeTable {
6170	typedef SpaceToDepthOptions TableType;
6171	int32_t block_size;
6172	SpaceToDepthOptionsT()
6173	: block_size(`0`) {
6174	}
6175	};
6176
6177	struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6178	typedef SpaceToDepthOptionsT NativeTableType;
6179	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6180	VT_BLOCK_SIZE = `4`
6181	};
6182	int32_t block_size() const {
6183	return GetField<int32_t>(VT_BLOCK_SIZE, `0`);
6184	}
6185	bool Verify(flatbuffers::Verifier &verifier) const {
6186	return VerifyTableStart(verifier) &&
6187	VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
6188	verifier.EndTable();
6189	}
6190	SpaceToDepthOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6191	void UnPackTo(SpaceToDepthOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6192	static flatbuffers::Offset<SpaceToDepthOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6193	};
6194
6195	struct SpaceToDepthOptionsBuilder {
6196	flatbuffers::FlatBufferBuilder &fbb_;
6197	flatbuffers::uoffset_t start_;
6198	void add_block_size(int32_t block_size) {
6199	fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, `0`);
6200	}
6201	explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6202	: fbb_(_fbb) {
6203	start_ = fbb_.StartTable();
6204	}
6205	SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &);
6206	flatbuffers::Offset<SpaceToDepthOptions> Finish() {
6207	const auto end = fbb_.EndTable(start_);
6208	auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
6209	return o;
6210	}
6211	};
6212
6213	inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
6214	flatbuffers::FlatBufferBuilder &_fbb,
6215	int32_t block_size = `0`) {
6216	SpaceToDepthOptionsBuilder builder_(_fbb);
6217	builder_.add_block_size(block_size);
6218	return builder_.Finish();
6219	}
6220
6221	flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6222
6223	struct DepthToSpaceOptionsT : public flatbuffers::NativeTable {
6224	typedef DepthToSpaceOptions TableType;
6225	int32_t block_size;
6226	DepthToSpaceOptionsT()
6227	: block_size(`0`) {
6228	}
6229	};
6230
6231	struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6232	typedef DepthToSpaceOptionsT NativeTableType;
6233	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6234	VT_BLOCK_SIZE = `4`
6235	};
6236	int32_t block_size() const {
6237	return GetField<int32_t>(VT_BLOCK_SIZE, `0`);
6238	}
6239	bool Verify(flatbuffers::Verifier &verifier) const {
6240	return VerifyTableStart(verifier) &&
6241	VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
6242	verifier.EndTable();
6243	}
6244	DepthToSpaceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6245	void UnPackTo(DepthToSpaceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6246	static flatbuffers::Offset<DepthToSpaceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6247	};
6248
6249	struct DepthToSpaceOptionsBuilder {
6250	flatbuffers::FlatBufferBuilder &fbb_;
6251	flatbuffers::uoffset_t start_;
6252	void add_block_size(int32_t block_size) {
6253	fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, `0`);
6254	}
6255	explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6256	: fbb_(_fbb) {
6257	start_ = fbb_.StartTable();
6258	}
6259	DepthToSpaceOptionsBuilder &operator=(const DepthToSpaceOptionsBuilder &);
6260	flatbuffers::Offset<DepthToSpaceOptions> Finish() {
6261	const auto end = fbb_.EndTable(start_);
6262	auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
6263	return o;
6264	}
6265	};
6266
6267	inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
6268	flatbuffers::FlatBufferBuilder &_fbb,
6269	int32_t block_size = `0`) {
6270	DepthToSpaceOptionsBuilder builder_(_fbb);
6271	builder_.add_block_size(block_size);
6272	return builder_.Finish();
6273	}
6274
6275	flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6276
6277	struct SubOptionsT : public flatbuffers::NativeTable {
6278	typedef SubOptions TableType;
6279	tflite::ActivationFunctionType fused_activation_function;
6280	bool pot_scale_int16;
6281	SubOptionsT()
6282	: fused_activation_function(tflite::ActivationFunctionType_NONE),
6283	pot_scale_int16(true) {
6284	}
6285	};
6286
6287	struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6288	typedef SubOptionsT NativeTableType;
6289	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6290	VT_FUSED_ACTIVATION_FUNCTION = `4`,
6291	VT_POT_SCALE_INT16 = `6`
6292	};
6293	tflite::ActivationFunctionType fused_activation_function() const {
6294	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6295	}
6296	bool pot_scale_int16() const {
6297	return GetField<uint8_t>(VT_POT_SCALE_INT16, `1`) != `0`;
6298	}
6299	bool Verify(flatbuffers::Verifier &verifier) const {
6300	return VerifyTableStart(verifier) &&
6301	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6302	VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) &&
6303	verifier.EndTable();
6304	}
6305	SubOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6306	void UnPackTo(SubOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6307	static flatbuffers::Offset<SubOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6308	};
6309
6310	struct SubOptionsBuilder {
6311	flatbuffers::FlatBufferBuilder &fbb_;
6312	flatbuffers::uoffset_t start_;
6313	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6314	fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6315	}
6316	void add_pot_scale_int16(bool pot_scale_int16) {
6317	fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), `1`);
6318	}
6319	explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6320	: fbb_(_fbb) {
6321	start_ = fbb_.StartTable();
6322	}
6323	SubOptionsBuilder &operator=(const SubOptionsBuilder &);
6324	flatbuffers::Offset<SubOptions> Finish() {
6325	const auto end = fbb_.EndTable(start_);
6326	auto o = flatbuffers::Offset<SubOptions>(end);
6327	return o;
6328	}
6329	};
6330
6331	inline flatbuffers::Offset<SubOptions> CreateSubOptions(
6332	flatbuffers::FlatBufferBuilder &_fbb,
6333	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
6334	bool pot_scale_int16 = true) {
6335	SubOptionsBuilder builder_(_fbb);
6336	builder_.add_pot_scale_int16(pot_scale_int16);
6337	builder_.add_fused_activation_function(fused_activation_function);
6338	return builder_.Finish();
6339	}
6340
6341	flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6342
6343	struct DivOptionsT : public flatbuffers::NativeTable {
6344	typedef DivOptions TableType;
6345	tflite::ActivationFunctionType fused_activation_function;
6346	DivOptionsT()
6347	: fused_activation_function(tflite::ActivationFunctionType_NONE) {
6348	}
6349	};
6350
6351	struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6352	typedef DivOptionsT NativeTableType;
6353	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6354	VT_FUSED_ACTIVATION_FUNCTION = `4`
6355	};
6356	tflite::ActivationFunctionType fused_activation_function() const {
6357	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6358	}
6359	bool Verify(flatbuffers::Verifier &verifier) const {
6360	return VerifyTableStart(verifier) &&
6361	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6362	verifier.EndTable();
6363	}
6364	DivOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6365	void UnPackTo(DivOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6366	static flatbuffers::Offset<DivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6367	};
6368
6369	struct DivOptionsBuilder {
6370	flatbuffers::FlatBufferBuilder &fbb_;
6371	flatbuffers::uoffset_t start_;
6372	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6373	fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6374	}
6375	explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6376	: fbb_(_fbb) {
6377	start_ = fbb_.StartTable();
6378	}
6379	DivOptionsBuilder &operator=(const DivOptionsBuilder &);
6380	flatbuffers::Offset<DivOptions> Finish() {
6381	const auto end = fbb_.EndTable(start_);
6382	auto o = flatbuffers::Offset<DivOptions>(end);
6383	return o;
6384	}
6385	};
6386
6387	inline flatbuffers::Offset<DivOptions> CreateDivOptions(
6388	flatbuffers::FlatBufferBuilder &_fbb,
6389	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
6390	DivOptionsBuilder builder_(_fbb);
6391	builder_.add_fused_activation_function(fused_activation_function);
6392	return builder_.Finish();
6393	}
6394
6395	flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6396
6397	struct TopKV2OptionsT : public flatbuffers::NativeTable {
6398	typedef TopKV2Options TableType;
6399	TopKV2OptionsT() {
6400	}
6401	};
6402
6403	struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6404	typedef TopKV2OptionsT NativeTableType;
6405	bool Verify(flatbuffers::Verifier &verifier) const {
6406	return VerifyTableStart(verifier) &&
6407	verifier.EndTable();
6408	}
6409	TopKV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6410	void UnPackTo(TopKV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6411	static flatbuffers::Offset<TopKV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6412	};
6413
6414	struct TopKV2OptionsBuilder {
6415	flatbuffers::FlatBufferBuilder &fbb_;
6416	flatbuffers::uoffset_t start_;
6417	explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6418	: fbb_(_fbb) {
6419	start_ = fbb_.StartTable();
6420	}
6421	TopKV2OptionsBuilder &operator=(const TopKV2OptionsBuilder &);
6422	flatbuffers::Offset<TopKV2Options> Finish() {
6423	const auto end = fbb_.EndTable(start_);
6424	auto o = flatbuffers::Offset<TopKV2Options>(end);
6425	return o;
6426	}
6427	};
6428
6429	inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
6430	flatbuffers::FlatBufferBuilder &_fbb) {
6431	TopKV2OptionsBuilder builder_(_fbb);
6432	return builder_.Finish();
6433	}
6434
6435	flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6436
6437	struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable {
6438	typedef EmbeddingLookupSparseOptions TableType;
6439	tflite::CombinerType combiner;
6440	EmbeddingLookupSparseOptionsT()
6441	: combiner(tflite::CombinerType_SUM) {
6442	}
6443	};
6444
6445	struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6446	typedef EmbeddingLookupSparseOptionsT NativeTableType;
6447	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6448	VT_COMBINER = `4`
6449	};
6450	tflite::CombinerType combiner() const {
6451	return static_cast<tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, `0`));
6452	}
6453	bool Verify(flatbuffers::Verifier &verifier) const {
6454	return VerifyTableStart(verifier) &&
6455	VerifyField<int8_t>(verifier, VT_COMBINER) &&
6456	verifier.EndTable();
6457	}
6458	EmbeddingLookupSparseOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6459	void UnPackTo(EmbeddingLookupSparseOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6460	static flatbuffers::Offset<EmbeddingLookupSparseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6461	};
6462
6463	struct EmbeddingLookupSparseOptionsBuilder {
6464	flatbuffers::FlatBufferBuilder &fbb_;
6465	flatbuffers::uoffset_t start_;
6466	void add_combiner(tflite::CombinerType combiner) {
6467	fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), `0`);
6468	}
6469	explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6470	: fbb_(_fbb) {
6471	start_ = fbb_.StartTable();
6472	}
6473	EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &);
6474	flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
6475	const auto end = fbb_.EndTable(start_);
6476	auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
6477	return o;
6478	}
6479	};
6480
6481	inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
6482	flatbuffers::FlatBufferBuilder &_fbb,
6483	tflite::CombinerType combiner = tflite::CombinerType_SUM) {
6484	EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
6485	builder_.add_combiner(combiner);
6486	return builder_.Finish();
6487	}
6488
6489	flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6490
6491	struct GatherOptionsT : public flatbuffers::NativeTable {
6492	typedef GatherOptions TableType;
6493	int32_t axis;
6494	int32_t batch_dims;
6495	GatherOptionsT()
6496	: axis(`0`),
6497	batch_dims(`0`) {
6498	}
6499	};
6500
6501	struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6502	typedef GatherOptionsT NativeTableType;
6503	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6504	VT_AXIS = `4`,
6505	VT_BATCH_DIMS = `6`
6506	};
6507	int32_t axis() const {
6508	return GetField<int32_t>(VT_AXIS, `0`);
6509	}
6510	int32_t batch_dims() const {
6511	return GetField<int32_t>(VT_BATCH_DIMS, `0`);
6512	}
6513	bool Verify(flatbuffers::Verifier &verifier) const {
6514	return VerifyTableStart(verifier) &&
6515	VerifyField<int32_t>(verifier, VT_AXIS) &&
6516	VerifyField<int32_t>(verifier, VT_BATCH_DIMS) &&
6517	verifier.EndTable();
6518	}
6519	GatherOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6520	void UnPackTo(GatherOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6521	static flatbuffers::Offset<GatherOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6522	};
6523
6524	struct GatherOptionsBuilder {
6525	flatbuffers::FlatBufferBuilder &fbb_;
6526	flatbuffers::uoffset_t start_;
6527	void add_axis(int32_t axis) {
6528	fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, `0`);
6529	}
6530	void add_batch_dims(int32_t batch_dims) {
6531	fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, `0`);
6532	}
6533	explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6534	: fbb_(_fbb) {
6535	start_ = fbb_.StartTable();
6536	}
6537	GatherOptionsBuilder &operator=(const GatherOptionsBuilder &);
6538	flatbuffers::Offset<GatherOptions> Finish() {
6539	const auto end = fbb_.EndTable(start_);
6540	auto o = flatbuffers::Offset<GatherOptions>(end);
6541	return o;
6542	}
6543	};
6544
6545	inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
6546	flatbuffers::FlatBufferBuilder &_fbb,
6547	int32_t axis = `0`,
6548	int32_t batch_dims = `0`) {
6549	GatherOptionsBuilder builder_(_fbb);
6550	builder_.add_batch_dims(batch_dims);
6551	builder_.add_axis(axis);
6552	return builder_.Finish();
6553	}
6554
6555	flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6556
6557	struct TransposeOptionsT : public flatbuffers::NativeTable {
6558	typedef TransposeOptions TableType;
6559	TransposeOptionsT() {
6560	}
6561	};
6562
6563	struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6564	typedef TransposeOptionsT NativeTableType;
6565	bool Verify(flatbuffers::Verifier &verifier) const {
6566	return VerifyTableStart(verifier) &&
6567	verifier.EndTable();
6568	}
6569	TransposeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6570	void UnPackTo(TransposeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6571	static flatbuffers::Offset<TransposeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6572	};
6573
6574	struct TransposeOptionsBuilder {
6575	flatbuffers::FlatBufferBuilder &fbb_;
6576	flatbuffers::uoffset_t start_;
6577	explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6578	: fbb_(_fbb) {
6579	start_ = fbb_.StartTable();
6580	}
6581	TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &);
6582	flatbuffers::Offset<TransposeOptions> Finish() {
6583	const auto end = fbb_.EndTable(start_);
6584	auto o = flatbuffers::Offset<TransposeOptions>(end);
6585	return o;
6586	}
6587	};
6588
6589	inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
6590	flatbuffers::FlatBufferBuilder &_fbb) {
6591	TransposeOptionsBuilder builder_(_fbb);
6592	return builder_.Finish();
6593	}
6594
6595	flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6596
6597	struct ExpOptionsT : public flatbuffers::NativeTable {
6598	typedef ExpOptions TableType;
6599	ExpOptionsT() {
6600	}
6601	};
6602
6603	struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6604	typedef ExpOptionsT NativeTableType;
6605	bool Verify(flatbuffers::Verifier &verifier) const {
6606	return VerifyTableStart(verifier) &&
6607	verifier.EndTable();
6608	}
6609	ExpOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6610	void UnPackTo(ExpOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6611	static flatbuffers::Offset<ExpOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6612	};
6613
6614	struct ExpOptionsBuilder {
6615	flatbuffers::FlatBufferBuilder &fbb_;
6616	flatbuffers::uoffset_t start_;
6617	explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6618	: fbb_(_fbb) {
6619	start_ = fbb_.StartTable();
6620	}
6621	ExpOptionsBuilder &operator=(const ExpOptionsBuilder &);
6622	flatbuffers::Offset<ExpOptions> Finish() {
6623	const auto end = fbb_.EndTable(start_);
6624	auto o = flatbuffers::Offset<ExpOptions>(end);
6625	return o;
6626	}
6627	};
6628
6629	inline flatbuffers::Offset<ExpOptions> CreateExpOptions(
6630	flatbuffers::FlatBufferBuilder &_fbb) {
6631	ExpOptionsBuilder builder_(_fbb);
6632	return builder_.Finish();
6633	}
6634
6635	flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6636
6637	struct CosOptionsT : public flatbuffers::NativeTable {
6638	typedef CosOptions TableType;
6639	CosOptionsT() {
6640	}
6641	};
6642
6643	struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6644	typedef CosOptionsT NativeTableType;
6645	bool Verify(flatbuffers::Verifier &verifier) const {
6646	return VerifyTableStart(verifier) &&
6647	verifier.EndTable();
6648	}
6649	CosOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6650	void UnPackTo(CosOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6651	static flatbuffers::Offset<CosOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6652	};
6653
6654	struct CosOptionsBuilder {
6655	flatbuffers::FlatBufferBuilder &fbb_;
6656	flatbuffers::uoffset_t start_;
6657	explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6658	: fbb_(_fbb) {
6659	start_ = fbb_.StartTable();
6660	}
6661	CosOptionsBuilder &operator=(const CosOptionsBuilder &);
6662	flatbuffers::Offset<CosOptions> Finish() {
6663	const auto end = fbb_.EndTable(start_);
6664	auto o = flatbuffers::Offset<CosOptions>(end);
6665	return o;
6666	}
6667	};
6668
6669	inline flatbuffers::Offset<CosOptions> CreateCosOptions(
6670	flatbuffers::FlatBufferBuilder &_fbb) {
6671	CosOptionsBuilder builder_(_fbb);
6672	return builder_.Finish();
6673	}
6674
6675	flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6676
6677	struct ReducerOptionsT : public flatbuffers::NativeTable {
6678	typedef ReducerOptions TableType;
6679	bool keep_dims;
6680	ReducerOptionsT()
6681	: keep_dims(false) {
6682	}
6683	};
6684
6685	struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6686	typedef ReducerOptionsT NativeTableType;
6687	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6688	VT_KEEP_DIMS = `4`
6689	};
6690	bool keep_dims() const {
6691	return GetField<uint8_t>(VT_KEEP_DIMS, `0`) != `0`;
6692	}
6693	bool Verify(flatbuffers::Verifier &verifier) const {
6694	return VerifyTableStart(verifier) &&
6695	VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
6696	verifier.EndTable();
6697	}
6698	ReducerOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6699	void UnPackTo(ReducerOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6700	static flatbuffers::Offset<ReducerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6701	};
6702
6703	struct ReducerOptionsBuilder {
6704	flatbuffers::FlatBufferBuilder &fbb_;
6705	flatbuffers::uoffset_t start_;
6706	void add_keep_dims(bool keep_dims) {
6707	fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), `0`);
6708	}
6709	explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6710	: fbb_(_fbb) {
6711	start_ = fbb_.StartTable();
6712	}
6713	ReducerOptionsBuilder &operator=(const ReducerOptionsBuilder &);
6714	flatbuffers::Offset<ReducerOptions> Finish() {
6715	const auto end = fbb_.EndTable(start_);
6716	auto o = flatbuffers::Offset<ReducerOptions>(end);
6717	return o;
6718	}
6719	};
6720
6721	inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
6722	flatbuffers::FlatBufferBuilder &_fbb,
6723	bool keep_dims = false) {
6724	ReducerOptionsBuilder builder_(_fbb);
6725	builder_.add_keep_dims(keep_dims);
6726	return builder_.Finish();
6727	}
6728
6729	flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6730
6731	struct SqueezeOptionsT : public flatbuffers::NativeTable {
6732	typedef SqueezeOptions TableType;
6733	std::vector<int32_t> squeeze_dims;
6734	SqueezeOptionsT() {
6735	}
6736	};
6737
6738	struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6739	typedef SqueezeOptionsT NativeTableType;
6740	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6741	VT_SQUEEZE_DIMS = `4`
6742	};
6743	const flatbuffers::Vector<int32_t> squeeze_dims() const* {
6744	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
6745	}
6746	bool Verify(flatbuffers::Verifier &verifier) const {
6747	return VerifyTableStart(verifier) &&
6748	VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
6749	verifier.VerifyVector(squeeze_dims()) &&
6750	verifier.EndTable();
6751	}
6752	SqueezeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6753	void UnPackTo(SqueezeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6754	static flatbuffers::Offset<SqueezeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6755	};
6756
6757	struct SqueezeOptionsBuilder {
6758	flatbuffers::FlatBufferBuilder &fbb_;
6759	flatbuffers::uoffset_t start_;
6760	void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) {
6761	fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
6762	}
6763	explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6764	: fbb_(_fbb) {
6765	start_ = fbb_.StartTable();
6766	}
6767	SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &);
6768	flatbuffers::Offset<SqueezeOptions> Finish() {
6769	const auto end = fbb_.EndTable(start_);
6770	auto o = flatbuffers::Offset<SqueezeOptions>(end);
6771	return o;
6772	}
6773	};
6774
6775	inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
6776	flatbuffers::FlatBufferBuilder &_fbb,
6777	flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = `0`) {
6778	SqueezeOptionsBuilder builder_(_fbb);
6779	builder_.add_squeeze_dims(squeeze_dims);
6780	return builder_.Finish();
6781	}
6782
6783	inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
6784	flatbuffers::FlatBufferBuilder &_fbb,
6785	const std::vector<int32_t> squeeze_dims = nullptr*) {
6786	auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : `0`;
6787	return tflite::CreateSqueezeOptions(
6788	_fbb,
6789	squeeze_dims__);
6790	}
6791
6792	flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6793
6794	struct SplitOptionsT : public flatbuffers::NativeTable {
6795	typedef SplitOptions TableType;
6796	int32_t num_splits;
6797	SplitOptionsT()
6798	: num_splits(`0`) {
6799	}
6800	};
6801
6802	struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6803	typedef SplitOptionsT NativeTableType;
6804	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6805	VT_NUM_SPLITS = `4`
6806	};
6807	int32_t num_splits() const {
6808	return GetField<int32_t>(VT_NUM_SPLITS, `0`);
6809	}
6810	bool Verify(flatbuffers::Verifier &verifier) const {
6811	return VerifyTableStart(verifier) &&
6812	VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
6813	verifier.EndTable();
6814	}
6815	SplitOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6816	void UnPackTo(SplitOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6817	static flatbuffers::Offset<SplitOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6818	};
6819
6820	struct SplitOptionsBuilder {
6821	flatbuffers::FlatBufferBuilder &fbb_;
6822	flatbuffers::uoffset_t start_;
6823	void add_num_splits(int32_t num_splits) {
6824	fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, `0`);
6825	}
6826	explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6827	: fbb_(_fbb) {
6828	start_ = fbb_.StartTable();
6829	}
6830	SplitOptionsBuilder &operator=(const SplitOptionsBuilder &);
6831	flatbuffers::Offset<SplitOptions> Finish() {
6832	const auto end = fbb_.EndTable(start_);
6833	auto o = flatbuffers::Offset<SplitOptions>(end);
6834	return o;
6835	}
6836	};
6837
6838	inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(
6839	flatbuffers::FlatBufferBuilder &_fbb,
6840	int32_t num_splits = `0`) {
6841	SplitOptionsBuilder builder_(_fbb);
6842	builder_.add_num_splits(num_splits);
6843	return builder_.Finish();
6844	}
6845
6846	flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6847
6848	struct SplitVOptionsT : public flatbuffers::NativeTable {
6849	typedef SplitVOptions TableType;
6850	int32_t num_splits;
6851	SplitVOptionsT()
6852	: num_splits(`0`) {
6853	}
6854	};
6855
6856	struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6857	typedef SplitVOptionsT NativeTableType;
6858	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6859	VT_NUM_SPLITS = `4`
6860	};
6861	int32_t num_splits() const {
6862	return GetField<int32_t>(VT_NUM_SPLITS, `0`);
6863	}
6864	bool Verify(flatbuffers::Verifier &verifier) const {
6865	return VerifyTableStart(verifier) &&
6866	VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
6867	verifier.EndTable();
6868	}
6869	SplitVOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6870	void UnPackTo(SplitVOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6871	static flatbuffers::Offset<SplitVOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6872	};
6873
6874	struct SplitVOptionsBuilder {
6875	flatbuffers::FlatBufferBuilder &fbb_;
6876	flatbuffers::uoffset_t start_;
6877	void add_num_splits(int32_t num_splits) {
6878	fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, `0`);
6879	}
6880	explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6881	: fbb_(_fbb) {
6882	start_ = fbb_.StartTable();
6883	}
6884	SplitVOptionsBuilder &operator=(const SplitVOptionsBuilder &);
6885	flatbuffers::Offset<SplitVOptions> Finish() {
6886	const auto end = fbb_.EndTable(start_);
6887	auto o = flatbuffers::Offset<SplitVOptions>(end);
6888	return o;
6889	}
6890	};
6891
6892	inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
6893	flatbuffers::FlatBufferBuilder &_fbb,
6894	int32_t num_splits = `0`) {
6895	SplitVOptionsBuilder builder_(_fbb);
6896	builder_.add_num_splits(num_splits);
6897	return builder_.Finish();
6898	}
6899
6900	flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6901
6902	struct StridedSliceOptionsT : public flatbuffers::NativeTable {
6903	typedef StridedSliceOptions TableType;
6904	int32_t begin_mask;
6905	int32_t end_mask;
6906	int32_t ellipsis_mask;
6907	int32_t new_axis_mask;
6908	int32_t shrink_axis_mask;
6909	StridedSliceOptionsT()
6910	: begin_mask(`0`),
6911	end_mask(`0`),
6912	ellipsis_mask(`0`),
6913	new_axis_mask(`0`),
6914	shrink_axis_mask(`0`) {
6915	}
6916	};
6917
6918	struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6919	typedef StridedSliceOptionsT NativeTableType;
6920	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6921	VT_BEGIN_MASK = `4`,
6922	VT_END_MASK = `6`,
6923	VT_ELLIPSIS_MASK = `8`,
6924	VT_NEW_AXIS_MASK = `10`,
6925	VT_SHRINK_AXIS_MASK = `12`
6926	};
6927	int32_t begin_mask() const {
6928	return GetField<int32_t>(VT_BEGIN_MASK, `0`);
6929	}
6930	int32_t end_mask() const {
6931	return GetField<int32_t>(VT_END_MASK, `0`);
6932	}
6933	int32_t ellipsis_mask() const {
6934	return GetField<int32_t>(VT_ELLIPSIS_MASK, `0`);
6935	}
6936	int32_t new_axis_mask() const {
6937	return GetField<int32_t>(VT_NEW_AXIS_MASK, `0`);
6938	}
6939	int32_t shrink_axis_mask() const {
6940	return GetField<int32_t>(VT_SHRINK_AXIS_MASK, `0`);
6941	}
6942	bool Verify(flatbuffers::Verifier &verifier) const {
6943	return VerifyTableStart(verifier) &&
6944	VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
6945	VerifyField<int32_t>(verifier, VT_END_MASK) &&
6946	VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
6947	VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
6948	VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) &&
6949	verifier.EndTable();
6950	}
6951	StridedSliceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6952	void UnPackTo(StridedSliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6953	static flatbuffers::Offset<StridedSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6954	};
6955
6956	struct StridedSliceOptionsBuilder {
6957	flatbuffers::FlatBufferBuilder &fbb_;
6958	flatbuffers::uoffset_t start_;
6959	void add_begin_mask(int32_t begin_mask) {
6960	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, `0`);
6961	}
6962	void add_end_mask(int32_t end_mask) {
6963	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, `0`);
6964	}
6965	void add_ellipsis_mask(int32_t ellipsis_mask) {
6966	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, `0`);
6967	}
6968	void add_new_axis_mask(int32_t new_axis_mask) {
6969	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, `0`);
6970	}
6971	void add_shrink_axis_mask(int32_t shrink_axis_mask) {
6972	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, `0`);
6973	}
6974	explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6975	: fbb_(_fbb) {
6976	start_ = fbb_.StartTable();
6977	}
6978	StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &);
6979	flatbuffers::Offset<StridedSliceOptions> Finish() {
6980	const auto end = fbb_.EndTable(start_);
6981	auto o = flatbuffers::Offset<StridedSliceOptions>(end);
6982	return o;
6983	}
6984	};
6985
6986	inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
6987	flatbuffers::FlatBufferBuilder &_fbb,
6988	int32_t begin_mask = `0`,
6989	int32_t end_mask = `0`,
6990	int32_t ellipsis_mask = `0`,
6991	int32_t new_axis_mask = `0`,
6992	int32_t shrink_axis_mask = `0`) {
6993	StridedSliceOptionsBuilder builder_(_fbb);
6994	builder_.add_shrink_axis_mask(shrink_axis_mask);
6995	builder_.add_new_axis_mask(new_axis_mask);
6996	builder_.add_ellipsis_mask(ellipsis_mask);
6997	builder_.add_end_mask(end_mask);
6998	builder_.add_begin_mask(begin_mask);
6999	return builder_.Finish();
7000	}
7001
7002	flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7003
7004	struct LogSoftmaxOptionsT : public flatbuffers::NativeTable {
7005	typedef LogSoftmaxOptions TableType;
7006	LogSoftmaxOptionsT() {
7007	}
7008	};
7009
7010	struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7011	typedef LogSoftmaxOptionsT NativeTableType;
7012	bool Verify(flatbuffers::Verifier &verifier) const {
7013	return VerifyTableStart(verifier) &&
7014	verifier.EndTable();
7015	}
7016	LogSoftmaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7017	void UnPackTo(LogSoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7018	static flatbuffers::Offset<LogSoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7019	};
7020
7021	struct LogSoftmaxOptionsBuilder {
7022	flatbuffers::FlatBufferBuilder &fbb_;
7023	flatbuffers::uoffset_t start_;
7024	explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7025	: fbb_(_fbb) {
7026	start_ = fbb_.StartTable();
7027	}
7028	LogSoftmaxOptionsBuilder &operator=(const LogSoftmaxOptionsBuilder &);
7029	flatbuffers::Offset<LogSoftmaxOptions> Finish() {
7030	const auto end = fbb_.EndTable(start_);
7031	auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
7032	return o;
7033	}
7034	};
7035
7036	inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
7037	flatbuffers::FlatBufferBuilder &_fbb) {
7038	LogSoftmaxOptionsBuilder builder_(_fbb);
7039	return builder_.Finish();
7040	}
7041
7042	flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7043
7044	struct CastOptionsT : public flatbuffers::NativeTable {
7045	typedef CastOptions TableType;
7046	tflite::TensorType in_data_type;
7047	tflite::TensorType out_data_type;
7048	CastOptionsT()
7049	: in_data_type(tflite::TensorType_FLOAT32),
7050	out_data_type(tflite::TensorType_FLOAT32) {
7051	}
7052	};
7053
7054	struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7055	typedef CastOptionsT NativeTableType;
7056	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7057	VT_IN_DATA_TYPE = `4`,
7058	VT_OUT_DATA_TYPE = `6`
7059	};
7060	tflite::TensorType in_data_type() const {
7061	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, `0`));
7062	}
7063	tflite::TensorType out_data_type() const {
7064	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, `0`));
7065	}
7066	bool Verify(flatbuffers::Verifier &verifier) const {
7067	return VerifyTableStart(verifier) &&
7068	VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
7069	VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) &&
7070	verifier.EndTable();
7071	}
7072	CastOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7073	void UnPackTo(CastOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7074	static flatbuffers::Offset<CastOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7075	};
7076
7077	struct CastOptionsBuilder {
7078	flatbuffers::FlatBufferBuilder &fbb_;
7079	flatbuffers::uoffset_t start_;
7080	void add_in_data_type(tflite::TensorType in_data_type) {
7081	fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), `0`);
7082	}
7083	void add_out_data_type(tflite::TensorType out_data_type) {
7084	fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), `0`);
7085	}
7086	explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7087	: fbb_(_fbb) {
7088	start_ = fbb_.StartTable();
7089	}
7090	CastOptionsBuilder &operator=(const CastOptionsBuilder &);
7091	flatbuffers::Offset<CastOptions> Finish() {
7092	const auto end = fbb_.EndTable(start_);
7093	auto o = flatbuffers::Offset<CastOptions>(end);
7094	return o;
7095	}
7096	};
7097
7098	inline flatbuffers::Offset<CastOptions> CreateCastOptions(
7099	flatbuffers::FlatBufferBuilder &_fbb,
7100	tflite::TensorType in_data_type = tflite::TensorType_FLOAT32,
7101	tflite::TensorType out_data_type = tflite::TensorType_FLOAT32) {
7102	CastOptionsBuilder builder_(_fbb);
7103	builder_.add_out_data_type(out_data_type);
7104	builder_.add_in_data_type(in_data_type);
7105	return builder_.Finish();
7106	}
7107
7108	flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7109
7110	struct DequantizeOptionsT : public flatbuffers::NativeTable {
7111	typedef DequantizeOptions TableType;
7112	DequantizeOptionsT() {
7113	}
7114	};
7115
7116	struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7117	typedef DequantizeOptionsT NativeTableType;
7118	bool Verify(flatbuffers::Verifier &verifier) const {
7119	return VerifyTableStart(verifier) &&
7120	verifier.EndTable();
7121	}
7122	DequantizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7123	void UnPackTo(DequantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7124	static flatbuffers::Offset<DequantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7125	};
7126
7127	struct DequantizeOptionsBuilder {
7128	flatbuffers::FlatBufferBuilder &fbb_;
7129	flatbuffers::uoffset_t start_;
7130	explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7131	: fbb_(_fbb) {
7132	start_ = fbb_.StartTable();
7133	}
7134	DequantizeOptionsBuilder &operator=(const DequantizeOptionsBuilder &);
7135	flatbuffers::Offset<DequantizeOptions> Finish() {
7136	const auto end = fbb_.EndTable(start_);
7137	auto o = flatbuffers::Offset<DequantizeOptions>(end);
7138	return o;
7139	}
7140	};
7141
7142	inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
7143	flatbuffers::FlatBufferBuilder &_fbb) {
7144	DequantizeOptionsBuilder builder_(_fbb);
7145	return builder_.Finish();
7146	}
7147
7148	flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7149
7150	struct MaximumMinimumOptionsT : public flatbuffers::NativeTable {
7151	typedef MaximumMinimumOptions TableType;
7152	MaximumMinimumOptionsT() {
7153	}
7154	};
7155
7156	struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7157	typedef MaximumMinimumOptionsT NativeTableType;
7158	bool Verify(flatbuffers::Verifier &verifier) const {
7159	return VerifyTableStart(verifier) &&
7160	verifier.EndTable();
7161	}
7162	MaximumMinimumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7163	void UnPackTo(MaximumMinimumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7164	static flatbuffers::Offset<MaximumMinimumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7165	};
7166
7167	struct MaximumMinimumOptionsBuilder {
7168	flatbuffers::FlatBufferBuilder &fbb_;
7169	flatbuffers::uoffset_t start_;
7170	explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7171	: fbb_(_fbb) {
7172	start_ = fbb_.StartTable();
7173	}
7174	MaximumMinimumOptionsBuilder &operator=(const MaximumMinimumOptionsBuilder &);
7175	flatbuffers::Offset<MaximumMinimumOptions> Finish() {
7176	const auto end = fbb_.EndTable(start_);
7177	auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
7178	return o;
7179	}
7180	};
7181
7182	inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
7183	flatbuffers::FlatBufferBuilder &_fbb) {
7184	MaximumMinimumOptionsBuilder builder_(_fbb);
7185	return builder_.Finish();
7186	}
7187
7188	flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7189
7190	struct TileOptionsT : public flatbuffers::NativeTable {
7191	typedef TileOptions TableType;
7192	TileOptionsT() {
7193	}
7194	};
7195
7196	struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7197	typedef TileOptionsT NativeTableType;
7198	bool Verify(flatbuffers::Verifier &verifier) const {
7199	return VerifyTableStart(verifier) &&
7200	verifier.EndTable();
7201	}
7202	TileOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7203	void UnPackTo(TileOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7204	static flatbuffers::Offset<TileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7205	};
7206
7207	struct TileOptionsBuilder {
7208	flatbuffers::FlatBufferBuilder &fbb_;
7209	flatbuffers::uoffset_t start_;
7210	explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7211	: fbb_(_fbb) {
7212	start_ = fbb_.StartTable();
7213	}
7214	TileOptionsBuilder &operator=(const TileOptionsBuilder &);
7215	flatbuffers::Offset<TileOptions> Finish() {
7216	const auto end = fbb_.EndTable(start_);
7217	auto o = flatbuffers::Offset<TileOptions>(end);
7218	return o;
7219	}
7220	};
7221
7222	inline flatbuffers::Offset<TileOptions> CreateTileOptions(
7223	flatbuffers::FlatBufferBuilder &_fbb) {
7224	TileOptionsBuilder builder_(_fbb);
7225	return builder_.Finish();
7226	}
7227
7228	flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7229
7230	struct ArgMaxOptionsT : public flatbuffers::NativeTable {
7231	typedef ArgMaxOptions TableType;
7232	tflite::TensorType output_type;
7233	ArgMaxOptionsT()
7234	: output_type(tflite::TensorType_FLOAT32) {
7235	}
7236	};
7237
7238	struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7239	typedef ArgMaxOptionsT NativeTableType;
7240	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7241	VT_OUTPUT_TYPE = `4`
7242	};
7243	tflite::TensorType output_type() const {
7244	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, `0`));
7245	}
7246	bool Verify(flatbuffers::Verifier &verifier) const {
7247	return VerifyTableStart(verifier) &&
7248	VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
7249	verifier.EndTable();
7250	}
7251	ArgMaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7252	void UnPackTo(ArgMaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7253	static flatbuffers::Offset<ArgMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7254	};
7255
7256	struct ArgMaxOptionsBuilder {
7257	flatbuffers::FlatBufferBuilder &fbb_;
7258	flatbuffers::uoffset_t start_;
7259	void add_output_type(tflite::TensorType output_type) {
7260	fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), `0`);
7261	}
7262	explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7263	: fbb_(_fbb) {
7264	start_ = fbb_.StartTable();
7265	}
7266	ArgMaxOptionsBuilder &operator=(const ArgMaxOptionsBuilder &);
7267	flatbuffers::Offset<ArgMaxOptions> Finish() {
7268	const auto end = fbb_.EndTable(start_);
7269	auto o = flatbuffers::Offset<ArgMaxOptions>(end);
7270	return o;
7271	}
7272	};
7273
7274	inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
7275	flatbuffers::FlatBufferBuilder &_fbb,
7276	tflite::TensorType output_type = tflite::TensorType_FLOAT32) {
7277	ArgMaxOptionsBuilder builder_(_fbb);
7278	builder_.add_output_type(output_type);
7279	return builder_.Finish();
7280	}
7281
7282	flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7283
7284	struct ArgMinOptionsT : public flatbuffers::NativeTable {
7285	typedef ArgMinOptions TableType;
7286	tflite::TensorType output_type;
7287	ArgMinOptionsT()
7288	: output_type(tflite::TensorType_FLOAT32) {
7289	}
7290	};
7291
7292	struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7293	typedef ArgMinOptionsT NativeTableType;
7294	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7295	VT_OUTPUT_TYPE = `4`
7296	};
7297	tflite::TensorType output_type() const {
7298	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, `0`));
7299	}
7300	bool Verify(flatbuffers::Verifier &verifier) const {
7301	return VerifyTableStart(verifier) &&
7302	VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
7303	verifier.EndTable();
7304	}
7305	ArgMinOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7306	void UnPackTo(ArgMinOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7307	static flatbuffers::Offset<ArgMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7308	};
7309
7310	struct ArgMinOptionsBuilder {
7311	flatbuffers::FlatBufferBuilder &fbb_;
7312	flatbuffers::uoffset_t start_;
7313	void add_output_type(tflite::TensorType output_type) {
7314	fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), `0`);
7315	}
7316	explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7317	: fbb_(_fbb) {
7318	start_ = fbb_.StartTable();
7319	}
7320	ArgMinOptionsBuilder &operator=(const ArgMinOptionsBuilder &);
7321	flatbuffers::Offset<ArgMinOptions> Finish() {
7322	const auto end = fbb_.EndTable(start_);
7323	auto o = flatbuffers::Offset<ArgMinOptions>(end);
7324	return o;
7325	}
7326	};
7327
7328	inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
7329	flatbuffers::FlatBufferBuilder &_fbb,
7330	tflite::TensorType output_type = tflite::TensorType_FLOAT32) {
7331	ArgMinOptionsBuilder builder_(_fbb);
7332	builder_.add_output_type(output_type);
7333	return builder_.Finish();
7334	}
7335
7336	flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7337
7338	struct GreaterOptionsT : public flatbuffers::NativeTable {
7339	typedef GreaterOptions TableType;
7340	GreaterOptionsT() {
7341	}
7342	};
7343
7344	struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7345	typedef GreaterOptionsT NativeTableType;
7346	bool Verify(flatbuffers::Verifier &verifier) const {
7347	return VerifyTableStart(verifier) &&
7348	verifier.EndTable();
7349	}
7350	GreaterOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7351	void UnPackTo(GreaterOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7352	static flatbuffers::Offset<GreaterOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7353	};
7354
7355	struct GreaterOptionsBuilder {
7356	flatbuffers::FlatBufferBuilder &fbb_;
7357	flatbuffers::uoffset_t start_;
7358	explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7359	: fbb_(_fbb) {
7360	start_ = fbb_.StartTable();
7361	}
7362	GreaterOptionsBuilder &operator=(const GreaterOptionsBuilder &);
7363	flatbuffers::Offset<GreaterOptions> Finish() {
7364	const auto end = fbb_.EndTable(start_);
7365	auto o = flatbuffers::Offset<GreaterOptions>(end);
7366	return o;
7367	}
7368	};
7369
7370	inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
7371	flatbuffers::FlatBufferBuilder &_fbb) {
7372	GreaterOptionsBuilder builder_(_fbb);
7373	return builder_.Finish();
7374	}
7375
7376	flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7377
7378	struct GreaterEqualOptionsT : public flatbuffers::NativeTable {
7379	typedef GreaterEqualOptions TableType;
7380	GreaterEqualOptionsT() {
7381	}
7382	};
7383
7384	struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7385	typedef GreaterEqualOptionsT NativeTableType;
7386	bool Verify(flatbuffers::Verifier &verifier) const {
7387	return VerifyTableStart(verifier) &&
7388	verifier.EndTable();
7389	}
7390	GreaterEqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7391	void UnPackTo(GreaterEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7392	static flatbuffers::Offset<GreaterEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7393	};
7394
7395	struct GreaterEqualOptionsBuilder {
7396	flatbuffers::FlatBufferBuilder &fbb_;
7397	flatbuffers::uoffset_t start_;
7398	explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7399	: fbb_(_fbb) {
7400	start_ = fbb_.StartTable();
7401	}
7402	GreaterEqualOptionsBuilder &operator=(const GreaterEqualOptionsBuilder &);
7403	flatbuffers::Offset<GreaterEqualOptions> Finish() {
7404	const auto end = fbb_.EndTable(start_);
7405	auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
7406	return o;
7407	}
7408	};
7409
7410	inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
7411	flatbuffers::FlatBufferBuilder &_fbb) {
7412	GreaterEqualOptionsBuilder builder_(_fbb);
7413	return builder_.Finish();
7414	}
7415
7416	flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7417
7418	struct LessOptionsT : public flatbuffers::NativeTable {
7419	typedef LessOptions TableType;
7420	LessOptionsT() {
7421	}
7422	};
7423
7424	struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7425	typedef LessOptionsT NativeTableType;
7426	bool Verify(flatbuffers::Verifier &verifier) const {
7427	return VerifyTableStart(verifier) &&
7428	verifier.EndTable();
7429	}
7430	LessOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7431	void UnPackTo(LessOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7432	static flatbuffers::Offset<LessOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7433	};
7434
7435	struct LessOptionsBuilder {
7436	flatbuffers::FlatBufferBuilder &fbb_;
7437	flatbuffers::uoffset_t start_;
7438	explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7439	: fbb_(_fbb) {
7440	start_ = fbb_.StartTable();
7441	}
7442	LessOptionsBuilder &operator=(const LessOptionsBuilder &);
7443	flatbuffers::Offset<LessOptions> Finish() {
7444	const auto end = fbb_.EndTable(start_);
7445	auto o = flatbuffers::Offset<LessOptions>(end);
7446	return o;
7447	}
7448	};
7449
7450	inline flatbuffers::Offset<LessOptions> CreateLessOptions(
7451	flatbuffers::FlatBufferBuilder &_fbb) {
7452	LessOptionsBuilder builder_(_fbb);
7453	return builder_.Finish();
7454	}
7455
7456	flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7457
7458	struct LessEqualOptionsT : public flatbuffers::NativeTable {
7459	typedef LessEqualOptions TableType;
7460	LessEqualOptionsT() {
7461	}
7462	};
7463
7464	struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7465	typedef LessEqualOptionsT NativeTableType;
7466	bool Verify(flatbuffers::Verifier &verifier) const {
7467	return VerifyTableStart(verifier) &&
7468	verifier.EndTable();
7469	}
7470	LessEqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7471	void UnPackTo(LessEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7472	static flatbuffers::Offset<LessEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7473	};
7474
7475	struct LessEqualOptionsBuilder {
7476	flatbuffers::FlatBufferBuilder &fbb_;
7477	flatbuffers::uoffset_t start_;
7478	explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7479	: fbb_(_fbb) {
7480	start_ = fbb_.StartTable();
7481	}
7482	LessEqualOptionsBuilder &operator=(const LessEqualOptionsBuilder &);
7483	flatbuffers::Offset<LessEqualOptions> Finish() {
7484	const auto end = fbb_.EndTable(start_);
7485	auto o = flatbuffers::Offset<LessEqualOptions>(end);
7486	return o;
7487	}
7488	};
7489
7490	inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
7491	flatbuffers::FlatBufferBuilder &_fbb) {
7492	LessEqualOptionsBuilder builder_(_fbb);
7493	return builder_.Finish();
7494	}
7495
7496	flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7497
7498	struct NegOptionsT : public flatbuffers::NativeTable {
7499	typedef NegOptions TableType;
7500	NegOptionsT() {
7501	}
7502	};
7503
7504	struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7505	typedef NegOptionsT NativeTableType;
7506	bool Verify(flatbuffers::Verifier &verifier) const {
7507	return VerifyTableStart(verifier) &&
7508	verifier.EndTable();
7509	}
7510	NegOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7511	void UnPackTo(NegOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7512	static flatbuffers::Offset<NegOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7513	};
7514
7515	struct NegOptionsBuilder {
7516	flatbuffers::FlatBufferBuilder &fbb_;
7517	flatbuffers::uoffset_t start_;
7518	explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7519	: fbb_(_fbb) {
7520	start_ = fbb_.StartTable();
7521	}
7522	NegOptionsBuilder &operator=(const NegOptionsBuilder &);
7523	flatbuffers::Offset<NegOptions> Finish() {
7524	const auto end = fbb_.EndTable(start_);
7525	auto o = flatbuffers::Offset<NegOptions>(end);
7526	return o;
7527	}
7528	};
7529
7530	inline flatbuffers::Offset<NegOptions> CreateNegOptions(
7531	flatbuffers::FlatBufferBuilder &_fbb) {
7532	NegOptionsBuilder builder_(_fbb);
7533	return builder_.Finish();
7534	}
7535
7536	flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7537
7538	struct SelectOptionsT : public flatbuffers::NativeTable {
7539	typedef SelectOptions TableType;
7540	SelectOptionsT() {
7541	}
7542	};
7543
7544	struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7545	typedef SelectOptionsT NativeTableType;
7546	bool Verify(flatbuffers::Verifier &verifier) const {
7547	return VerifyTableStart(verifier) &&
7548	verifier.EndTable();
7549	}
7550	SelectOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7551	void UnPackTo(SelectOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7552	static flatbuffers::Offset<SelectOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7553	};
7554
7555	struct SelectOptionsBuilder {
7556	flatbuffers::FlatBufferBuilder &fbb_;
7557	flatbuffers::uoffset_t start_;
7558	explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7559	: fbb_(_fbb) {
7560	start_ = fbb_.StartTable();
7561	}
7562	SelectOptionsBuilder &operator=(const SelectOptionsBuilder &);
7563	flatbuffers::Offset<SelectOptions> Finish() {
7564	const auto end = fbb_.EndTable(start_);
7565	auto o = flatbuffers::Offset<SelectOptions>(end);
7566	return o;
7567	}
7568	};
7569
7570	inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(
7571	flatbuffers::FlatBufferBuilder &_fbb) {
7572	SelectOptionsBuilder builder_(_fbb);
7573	return builder_.Finish();
7574	}
7575
7576	flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7577
7578	struct SliceOptionsT : public flatbuffers::NativeTable {
7579	typedef SliceOptions TableType;
7580	SliceOptionsT() {
7581	}
7582	};
7583
7584	struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7585	typedef SliceOptionsT NativeTableType;
7586	bool Verify(flatbuffers::Verifier &verifier) const {
7587	return VerifyTableStart(verifier) &&
7588	verifier.EndTable();
7589	}
7590	SliceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7591	void UnPackTo(SliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7592	static flatbuffers::Offset<SliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7593	};
7594
7595	struct SliceOptionsBuilder {
7596	flatbuffers::FlatBufferBuilder &fbb_;
7597	flatbuffers::uoffset_t start_;
7598	explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7599	: fbb_(_fbb) {
7600	start_ = fbb_.StartTable();
7601	}
7602	SliceOptionsBuilder &operator=(const SliceOptionsBuilder &);
7603	flatbuffers::Offset<SliceOptions> Finish() {
7604	const auto end = fbb_.EndTable(start_);
7605	auto o = flatbuffers::Offset<SliceOptions>(end);
7606	return o;
7607	}
7608	};
7609
7610	inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(
7611	flatbuffers::FlatBufferBuilder &_fbb) {
7612	SliceOptionsBuilder builder_(_fbb);
7613	return builder_.Finish();
7614	}
7615
7616	flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7617
7618	struct TransposeConvOptionsT : public flatbuffers::NativeTable {
7619	typedef TransposeConvOptions TableType;
7620	tflite::Padding padding;
7621	int32_t stride_w;
7622	int32_t stride_h;
7623	TransposeConvOptionsT()
7624	: padding(tflite::Padding_SAME),
7625	stride_w(`0`),
7626	stride_h(`0`) {
7627	}
7628	};
7629
7630	struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7631	typedef TransposeConvOptionsT NativeTableType;
7632	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7633	VT_PADDING = `4`,
7634	VT_STRIDE_W = `6`,
7635	VT_STRIDE_H = `8`
7636	};
7637	tflite::Padding padding() const {
7638	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
7639	}
7640	int32_t stride_w() const {
7641	return GetField<int32_t>(VT_STRIDE_W, `0`);
7642	}
7643	int32_t stride_h() const {
7644	return GetField<int32_t>(VT_STRIDE_H, `0`);
7645	}
7646	bool Verify(flatbuffers::Verifier &verifier) const {
7647	return VerifyTableStart(verifier) &&
7648	VerifyField<int8_t>(verifier, VT_PADDING) &&
7649	VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
7650	VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
7651	verifier.EndTable();
7652	}
7653	TransposeConvOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7654	void UnPackTo(TransposeConvOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7655	static flatbuffers::Offset<TransposeConvOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7656	};
7657
7658	struct TransposeConvOptionsBuilder {
7659	flatbuffers::FlatBufferBuilder &fbb_;
7660	flatbuffers::uoffset_t start_;
7661	void add_padding(tflite::Padding padding) {
7662	fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
7663	}
7664	void add_stride_w(int32_t stride_w) {
7665	fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, `0`);
7666	}
7667	void add_stride_h(int32_t stride_h) {
7668	fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, `0`);
7669	}
7670	explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7671	: fbb_(_fbb) {
7672	start_ = fbb_.StartTable();
7673	}
7674	TransposeConvOptionsBuilder &operator=(const TransposeConvOptionsBuilder &);
7675	flatbuffers::Offset<TransposeConvOptions> Finish() {
7676	const auto end = fbb_.EndTable(start_);
7677	auto o = flatbuffers::Offset<TransposeConvOptions>(end);
7678	return o;
7679	}
7680	};
7681
7682	inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
7683	flatbuffers::FlatBufferBuilder &_fbb,
7684	tflite::Padding padding = tflite::Padding_SAME,
7685	int32_t stride_w = `0`,
7686	int32_t stride_h = `0`) {
7687	TransposeConvOptionsBuilder builder_(_fbb);
7688	builder_.add_stride_h(stride_h);
7689	builder_.add_stride_w(stride_w);
7690	builder_.add_padding(padding);
7691	return builder_.Finish();
7692	}
7693
7694	flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7695
7696	struct ExpandDimsOptionsT : public flatbuffers::NativeTable {
7697	typedef ExpandDimsOptions TableType;
7698	ExpandDimsOptionsT() {
7699	}
7700	};
7701
7702	struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7703	typedef ExpandDimsOptionsT NativeTableType;
7704	bool Verify(flatbuffers::Verifier &verifier) const {
7705	return VerifyTableStart(verifier) &&
7706	verifier.EndTable();
7707	}
7708	ExpandDimsOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7709	void UnPackTo(ExpandDimsOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7710	static flatbuffers::Offset<ExpandDimsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7711	};
7712
7713	struct ExpandDimsOptionsBuilder {
7714	flatbuffers::FlatBufferBuilder &fbb_;
7715	flatbuffers::uoffset_t start_;
7716	explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7717	: fbb_(_fbb) {
7718	start_ = fbb_.StartTable();
7719	}
7720	ExpandDimsOptionsBuilder &operator=(const ExpandDimsOptionsBuilder &);
7721	flatbuffers::Offset<ExpandDimsOptions> Finish() {
7722	const auto end = fbb_.EndTable(start_);
7723	auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
7724	return o;
7725	}
7726	};
7727
7728	inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
7729	flatbuffers::FlatBufferBuilder &_fbb) {
7730	ExpandDimsOptionsBuilder builder_(_fbb);
7731	return builder_.Finish();
7732	}
7733
7734	flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7735
7736	struct SparseToDenseOptionsT : public flatbuffers::NativeTable {
7737	typedef SparseToDenseOptions TableType;
7738	bool validate_indices;
7739	SparseToDenseOptionsT()
7740	: validate_indices(false) {
7741	}
7742	};
7743
7744	struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7745	typedef SparseToDenseOptionsT NativeTableType;
7746	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7747	VT_VALIDATE_INDICES = `4`
7748	};
7749	bool validate_indices() const {
7750	return GetField<uint8_t>(VT_VALIDATE_INDICES, `0`) != `0`;
7751	}
7752	bool Verify(flatbuffers::Verifier &verifier) const {
7753	return VerifyTableStart(verifier) &&
7754	VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
7755	verifier.EndTable();
7756	}
7757	SparseToDenseOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7758	void UnPackTo(SparseToDenseOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7759	static flatbuffers::Offset<SparseToDenseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7760	};
7761
7762	struct SparseToDenseOptionsBuilder {
7763	flatbuffers::FlatBufferBuilder &fbb_;
7764	flatbuffers::uoffset_t start_;
7765	void add_validate_indices(bool validate_indices) {
7766	fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), `0`);
7767	}
7768	explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7769	: fbb_(_fbb) {
7770	start_ = fbb_.StartTable();
7771	}
7772	SparseToDenseOptionsBuilder &operator=(const SparseToDenseOptionsBuilder &);
7773	flatbuffers::Offset<SparseToDenseOptions> Finish() {
7774	const auto end = fbb_.EndTable(start_);
7775	auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
7776	return o;
7777	}
7778	};
7779
7780	inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
7781	flatbuffers::FlatBufferBuilder &_fbb,
7782	bool validate_indices = false) {
7783	SparseToDenseOptionsBuilder builder_(_fbb);
7784	builder_.add_validate_indices(validate_indices);
7785	return builder_.Finish();
7786	}
7787
7788	flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7789
7790	struct EqualOptionsT : public flatbuffers::NativeTable {
7791	typedef EqualOptions TableType;
7792	EqualOptionsT() {
7793	}
7794	};
7795
7796	struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7797	typedef EqualOptionsT NativeTableType;
7798	bool Verify(flatbuffers::Verifier &verifier) const {
7799	return VerifyTableStart(verifier) &&
7800	verifier.EndTable();
7801	}
7802	EqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7803	void UnPackTo(EqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7804	static flatbuffers::Offset<EqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7805	};
7806
7807	struct EqualOptionsBuilder {
7808	flatbuffers::FlatBufferBuilder &fbb_;
7809	flatbuffers::uoffset_t start_;
7810	explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7811	: fbb_(_fbb) {
7812	start_ = fbb_.StartTable();
7813	}
7814	EqualOptionsBuilder &operator=(const EqualOptionsBuilder &);
7815	flatbuffers::Offset<EqualOptions> Finish() {
7816	const auto end = fbb_.EndTable(start_);
7817	auto o = flatbuffers::Offset<EqualOptions>(end);
7818	return o;
7819	}
7820	};
7821
7822	inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(
7823	flatbuffers::FlatBufferBuilder &_fbb) {
7824	EqualOptionsBuilder builder_(_fbb);
7825	return builder_.Finish();
7826	}
7827
7828	flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7829
7830	struct NotEqualOptionsT : public flatbuffers::NativeTable {
7831	typedef NotEqualOptions TableType;
7832	NotEqualOptionsT() {
7833	}
7834	};
7835
7836	struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7837	typedef NotEqualOptionsT NativeTableType;
7838	bool Verify(flatbuffers::Verifier &verifier) const {
7839	return VerifyTableStart(verifier) &&
7840	verifier.EndTable();
7841	}
7842	NotEqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7843	void UnPackTo(NotEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7844	static flatbuffers::Offset<NotEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7845	};
7846
7847	struct NotEqualOptionsBuilder {
7848	flatbuffers::FlatBufferBuilder &fbb_;
7849	flatbuffers::uoffset_t start_;
7850	explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7851	: fbb_(_fbb) {
7852	start_ = fbb_.StartTable();
7853	}
7854	NotEqualOptionsBuilder &operator=(const NotEqualOptionsBuilder &);
7855	flatbuffers::Offset<NotEqualOptions> Finish() {
7856	const auto end = fbb_.EndTable(start_);
7857	auto o = flatbuffers::Offset<NotEqualOptions>(end);
7858	return o;
7859	}
7860	};
7861
7862	inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
7863	flatbuffers::FlatBufferBuilder &_fbb) {
7864	NotEqualOptionsBuilder builder_(_fbb);
7865	return builder_.Finish();
7866	}
7867
7868	flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7869
7870	struct ShapeOptionsT : public flatbuffers::NativeTable {
7871	typedef ShapeOptions TableType;
7872	tflite::TensorType out_type;
7873	ShapeOptionsT()
7874	: out_type(tflite::TensorType_FLOAT32) {
7875	}
7876	};
7877
7878	struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7879	typedef ShapeOptionsT NativeTableType;
7880	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7881	VT_OUT_TYPE = `4`
7882	};
7883	tflite::TensorType out_type() const {
7884	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, `0`));
7885	}
7886	bool Verify(flatbuffers::Verifier &verifier) const {
7887	return VerifyTableStart(verifier) &&
7888	VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
7889	verifier.EndTable();
7890	}
7891	ShapeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7892	void UnPackTo(ShapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7893	static flatbuffers::Offset<ShapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7894	};
7895
7896	struct ShapeOptionsBuilder {
7897	flatbuffers::FlatBufferBuilder &fbb_;
7898	flatbuffers::uoffset_t start_;
7899	void add_out_type(tflite::TensorType out_type) {
7900	fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), `0`);
7901	}
7902	explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7903	: fbb_(_fbb) {
7904	start_ = fbb_.StartTable();
7905	}
7906	ShapeOptionsBuilder &operator=(const ShapeOptionsBuilder &);
7907	flatbuffers::Offset<ShapeOptions> Finish() {
7908	const auto end = fbb_.EndTable(start_);
7909	auto o = flatbuffers::Offset<ShapeOptions>(end);
7910	return o;
7911	}
7912	};
7913
7914	inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
7915	flatbuffers::FlatBufferBuilder &_fbb,
7916	tflite::TensorType out_type = tflite::TensorType_FLOAT32) {
7917	ShapeOptionsBuilder builder_(_fbb);
7918	builder_.add_out_type(out_type);
7919	return builder_.Finish();
7920	}
7921
7922	flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7923
7924	struct RankOptionsT : public flatbuffers::NativeTable {
7925	typedef RankOptions TableType;
7926	RankOptionsT() {
7927	}
7928	};
7929
7930	struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7931	typedef RankOptionsT NativeTableType;
7932	bool Verify(flatbuffers::Verifier &verifier) const {
7933	return VerifyTableStart(verifier) &&
7934	verifier.EndTable();
7935	}
7936	RankOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7937	void UnPackTo(RankOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7938	static flatbuffers::Offset<RankOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7939	};
7940
7941	struct RankOptionsBuilder {
7942	flatbuffers::FlatBufferBuilder &fbb_;
7943	flatbuffers::uoffset_t start_;
7944	explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7945	: fbb_(_fbb) {
7946	start_ = fbb_.StartTable();
7947	}
7948	RankOptionsBuilder &operator=(const RankOptionsBuilder &);
7949	flatbuffers::Offset<RankOptions> Finish() {
7950	const auto end = fbb_.EndTable(start_);
7951	auto o = flatbuffers::Offset<RankOptions>(end);
7952	return o;
7953	}
7954	};
7955
7956	inline flatbuffers::Offset<RankOptions> CreateRankOptions(
7957	flatbuffers::FlatBufferBuilder &_fbb) {
7958	RankOptionsBuilder builder_(_fbb);
7959	return builder_.Finish();
7960	}
7961
7962	flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7963
7964	struct PowOptionsT : public flatbuffers::NativeTable {
7965	typedef PowOptions TableType;
7966	PowOptionsT() {
7967	}
7968	};
7969
7970	struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7971	typedef PowOptionsT NativeTableType;
7972	bool Verify(flatbuffers::Verifier &verifier) const {
7973	return VerifyTableStart(verifier) &&
7974	verifier.EndTable();
7975	}
7976	PowOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7977	void UnPackTo(PowOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7978	static flatbuffers::Offset<PowOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7979	};
7980
7981	struct PowOptionsBuilder {
7982	flatbuffers::FlatBufferBuilder &fbb_;
7983	flatbuffers::uoffset_t start_;
7984	explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7985	: fbb_(_fbb) {
7986	start_ = fbb_.StartTable();
7987	}
7988	PowOptionsBuilder &operator=(const PowOptionsBuilder &);
7989	flatbuffers::Offset<PowOptions> Finish() {
7990	const auto end = fbb_.EndTable(start_);
7991	auto o = flatbuffers::Offset<PowOptions>(end);
7992	return o;
7993	}
7994	};
7995
7996	inline flatbuffers::Offset<PowOptions> CreatePowOptions(
7997	flatbuffers::FlatBufferBuilder &_fbb) {
7998	PowOptionsBuilder builder_(_fbb);
7999	return builder_.Finish();
8000	}
8001
8002	flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8003
8004	struct FakeQuantOptionsT : public flatbuffers::NativeTable {
8005	typedef FakeQuantOptions TableType;
8006	float min;
8007	float max;
8008	int32_t num_bits;
8009	bool narrow_range;
8010	FakeQuantOptionsT()
8011	: min(`0.0f`),
8012	max(`0.0f`),
8013	num_bits(`0`),
8014	narrow_range(false) {
8015	}
8016	};
8017
8018	struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8019	typedef FakeQuantOptionsT NativeTableType;
8020	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8021	VT_MIN = `4`,
8022	VT_MAX = `6`,
8023	VT_NUM_BITS = `8`,
8024	VT_NARROW_RANGE = `10`
8025	};
8026	float min() const {
8027	return GetField<float>(VT_MIN, `0.0f`);
8028	}
8029	float max() const {
8030	return GetField<float>(VT_MAX, `0.0f`);
8031	}
8032	int32_t num_bits() const {
8033	return GetField<int32_t>(VT_NUM_BITS, `0`);
8034	}
8035	bool narrow_range() const {
8036	return GetField<uint8_t>(VT_NARROW_RANGE, `0`) != `0`;
8037	}
8038	bool Verify(flatbuffers::Verifier &verifier) const {
8039	return VerifyTableStart(verifier) &&
8040	VerifyField<float>(verifier, VT_MIN) &&
8041	VerifyField<float>(verifier, VT_MAX) &&
8042	VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
8043	VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) &&
8044	verifier.EndTable();
8045	}
8046	FakeQuantOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8047	void UnPackTo(FakeQuantOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8048	static flatbuffers::Offset<FakeQuantOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8049	};
8050
8051	struct FakeQuantOptionsBuilder {
8052	flatbuffers::FlatBufferBuilder &fbb_;
8053	flatbuffers::uoffset_t start_;
8054	void add_min(float min) {
8055	fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, `0.0f`);
8056	}
8057	void add_max(float max) {
8058	fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, `0.0f`);
8059	}
8060	void add_num_bits(int32_t num_bits) {
8061	fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, `0`);
8062	}
8063	void add_narrow_range(bool narrow_range) {
8064	fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), `0`);
8065	}
8066	explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8067	: fbb_(_fbb) {
8068	start_ = fbb_.StartTable();
8069	}
8070	FakeQuantOptionsBuilder &operator=(const FakeQuantOptionsBuilder &);
8071	flatbuffers::Offset<FakeQuantOptions> Finish() {
8072	const auto end = fbb_.EndTable(start_);
8073	auto o = flatbuffers::Offset<FakeQuantOptions>(end);
8074	return o;
8075	}
8076	};
8077
8078	inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
8079	flatbuffers::FlatBufferBuilder &_fbb,
8080	float min = `0.0f`,
8081	float max = `0.0f`,
8082	int32_t num_bits = `0`,
8083	bool narrow_range = false) {
8084	FakeQuantOptionsBuilder builder_(_fbb);
8085	builder_.add_num_bits(num_bits);
8086	builder_.add_max(max);
8087	builder_.add_min(min);
8088	builder_.add_narrow_range(narrow_range);
8089	return builder_.Finish();
8090	}
8091
8092	flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8093
8094	struct PackOptionsT : public flatbuffers::NativeTable {
8095	typedef PackOptions TableType;
8096	int32_t values_count;
8097	int32_t axis;
8098	PackOptionsT()
8099	: values_count(`0`),
8100	axis(`0`) {
8101	}
8102	};
8103
8104	struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8105	typedef PackOptionsT NativeTableType;
8106	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8107	VT_VALUES_COUNT = `4`,
8108	VT_AXIS = `6`
8109	};
8110	int32_t values_count() const {
8111	return GetField<int32_t>(VT_VALUES_COUNT, `0`);
8112	}
8113	int32_t axis() const {
8114	return GetField<int32_t>(VT_AXIS, `0`);
8115	}
8116	bool Verify(flatbuffers::Verifier &verifier) const {
8117	return VerifyTableStart(verifier) &&
8118	VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
8119	VerifyField<int32_t>(verifier, VT_AXIS) &&
8120	verifier.EndTable();
8121	}
8122	PackOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8123	void UnPackTo(PackOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8124	static flatbuffers::Offset<PackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8125	};
8126
8127	struct PackOptionsBuilder {
8128	flatbuffers::FlatBufferBuilder &fbb_;
8129	flatbuffers::uoffset_t start_;
8130	void add_values_count(int32_t values_count) {
8131	fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, `0`);
8132	}
8133	void add_axis(int32_t axis) {
8134	fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, `0`);
8135	}
8136	explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8137	: fbb_(_fbb) {
8138	start_ = fbb_.StartTable();
8139	}
8140	PackOptionsBuilder &operator=(const PackOptionsBuilder &);
8141	flatbuffers::Offset<PackOptions> Finish() {
8142	const auto end = fbb_.EndTable(start_);
8143	auto o = flatbuffers::Offset<PackOptions>(end);
8144	return o;
8145	}
8146	};
8147
8148	inline flatbuffers::Offset<PackOptions> CreatePackOptions(
8149	flatbuffers::FlatBufferBuilder &_fbb,
8150	int32_t values_count = `0`,
8151	int32_t axis = `0`) {
8152	PackOptionsBuilder builder_(_fbb);
8153	builder_.add_axis(axis);
8154	builder_.add_values_count(values_count);
8155	return builder_.Finish();
8156	}
8157
8158	flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8159
8160	struct LogicalOrOptionsT : public flatbuffers::NativeTable {
8161	typedef LogicalOrOptions TableType;
8162	LogicalOrOptionsT() {
8163	}
8164	};
8165
8166	struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8167	typedef LogicalOrOptionsT NativeTableType;
8168	bool Verify(flatbuffers::Verifier &verifier) const {
8169	return VerifyTableStart(verifier) &&
8170	verifier.EndTable();
8171	}
8172	LogicalOrOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8173	void UnPackTo(LogicalOrOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8174	static flatbuffers::Offset<LogicalOrOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8175	};
8176
8177	struct LogicalOrOptionsBuilder {
8178	flatbuffers::FlatBufferBuilder &fbb_;
8179	flatbuffers::uoffset_t start_;
8180	explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8181	: fbb_(_fbb) {
8182	start_ = fbb_.StartTable();
8183	}
8184	LogicalOrOptionsBuilder &operator=(const LogicalOrOptionsBuilder &);
8185	flatbuffers::Offset<LogicalOrOptions> Finish() {
8186	const auto end = fbb_.EndTable(start_);
8187	auto o = flatbuffers::Offset<LogicalOrOptions>(end);
8188	return o;
8189	}
8190	};
8191
8192	inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
8193	flatbuffers::FlatBufferBuilder &_fbb) {
8194	LogicalOrOptionsBuilder builder_(_fbb);
8195	return builder_.Finish();
8196	}
8197
8198	flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8199
8200	struct OneHotOptionsT : public flatbuffers::NativeTable {
8201	typedef OneHotOptions TableType;
8202	int32_t axis;
8203	OneHotOptionsT()
8204	: axis(`0`) {
8205	}
8206	};
8207
8208	struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8209	typedef OneHotOptionsT NativeTableType;
8210	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8211	VT_AXIS = `4`
8212	};
8213	int32_t axis() const {
8214	return GetField<int32_t>(VT_AXIS, `0`);
8215	}
8216	bool Verify(flatbuffers::Verifier &verifier) const {
8217	return VerifyTableStart(verifier) &&
8218	VerifyField<int32_t>(verifier, VT_AXIS) &&
8219	verifier.EndTable();
8220	}
8221	OneHotOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8222	void UnPackTo(OneHotOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8223	static flatbuffers::Offset<OneHotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8224	};
8225
8226	struct OneHotOptionsBuilder {
8227	flatbuffers::FlatBufferBuilder &fbb_;
8228	flatbuffers::uoffset_t start_;
8229	void add_axis(int32_t axis) {
8230	fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, `0`);
8231	}
8232	explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8233	: fbb_(_fbb) {
8234	start_ = fbb_.StartTable();
8235	}
8236	OneHotOptionsBuilder &operator=(const OneHotOptionsBuilder &);
8237	flatbuffers::Offset<OneHotOptions> Finish() {
8238	const auto end = fbb_.EndTable(start_);
8239	auto o = flatbuffers::Offset<OneHotOptions>(end);
8240	return o;
8241	}
8242	};
8243
8244	inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
8245	flatbuffers::FlatBufferBuilder &_fbb,
8246	int32_t axis = `0`) {
8247	OneHotOptionsBuilder builder_(_fbb);
8248	builder_.add_axis(axis);
8249	return builder_.Finish();
8250	}
8251
8252	flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8253
8254	struct AbsOptionsT : public flatbuffers::NativeTable {
8255	typedef AbsOptions TableType;
8256	AbsOptionsT() {
8257	}
8258	};
8259
8260	struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8261	typedef AbsOptionsT NativeTableType;
8262	bool Verify(flatbuffers::Verifier &verifier) const {
8263	return VerifyTableStart(verifier) &&
8264	verifier.EndTable();
8265	}
8266	AbsOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8267	void UnPackTo(AbsOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8268	static flatbuffers::Offset<AbsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8269	};
8270
8271	struct AbsOptionsBuilder {
8272	flatbuffers::FlatBufferBuilder &fbb_;
8273	flatbuffers::uoffset_t start_;
8274	explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8275	: fbb_(_fbb) {
8276	start_ = fbb_.StartTable();
8277	}
8278	AbsOptionsBuilder &operator=(const AbsOptionsBuilder &);
8279	flatbuffers::Offset<AbsOptions> Finish() {
8280	const auto end = fbb_.EndTable(start_);
8281	auto o = flatbuffers::Offset<AbsOptions>(end);
8282	return o;
8283	}
8284	};
8285
8286	inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(
8287	flatbuffers::FlatBufferBuilder &_fbb) {
8288	AbsOptionsBuilder builder_(_fbb);
8289	return builder_.Finish();
8290	}
8291
8292	flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8293
8294	struct HardSwishOptionsT : public flatbuffers::NativeTable {
8295	typedef HardSwishOptions TableType;
8296	HardSwishOptionsT() {
8297	}
8298	};
8299
8300	struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8301	typedef HardSwishOptionsT NativeTableType;
8302	bool Verify(flatbuffers::Verifier &verifier) const {
8303	return VerifyTableStart(verifier) &&
8304	verifier.EndTable();
8305	}
8306	HardSwishOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8307	void UnPackTo(HardSwishOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8308	static flatbuffers::Offset<HardSwishOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8309	};
8310
8311	struct HardSwishOptionsBuilder {
8312	flatbuffers::FlatBufferBuilder &fbb_;
8313	flatbuffers::uoffset_t start_;
8314	explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8315	: fbb_(_fbb) {
8316	start_ = fbb_.StartTable();
8317	}
8318	HardSwishOptionsBuilder &operator=(const HardSwishOptionsBuilder &);
8319	flatbuffers::Offset<HardSwishOptions> Finish() {
8320	const auto end = fbb_.EndTable(start_);
8321	auto o = flatbuffers::Offset<HardSwishOptions>(end);
8322	return o;
8323	}
8324	};
8325
8326	inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
8327	flatbuffers::FlatBufferBuilder &_fbb) {
8328	HardSwishOptionsBuilder builder_(_fbb);
8329	return builder_.Finish();
8330	}
8331
8332	flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8333
8334	struct LogicalAndOptionsT : public flatbuffers::NativeTable {
8335	typedef LogicalAndOptions TableType;
8336	LogicalAndOptionsT() {
8337	}
8338	};
8339
8340	struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8341	typedef LogicalAndOptionsT NativeTableType;
8342	bool Verify(flatbuffers::Verifier &verifier) const {
8343	return VerifyTableStart(verifier) &&
8344	verifier.EndTable();
8345	}
8346	LogicalAndOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8347	void UnPackTo(LogicalAndOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8348	static flatbuffers::Offset<LogicalAndOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8349	};
8350
8351	struct LogicalAndOptionsBuilder {
8352	flatbuffers::FlatBufferBuilder &fbb_;
8353	flatbuffers::uoffset_t start_;
8354	explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8355	: fbb_(_fbb) {
8356	start_ = fbb_.StartTable();
8357	}
8358	LogicalAndOptionsBuilder &operator=(const LogicalAndOptionsBuilder &);
8359	flatbuffers::Offset<LogicalAndOptions> Finish() {
8360	const auto end = fbb_.EndTable(start_);
8361	auto o = flatbuffers::Offset<LogicalAndOptions>(end);
8362	return o;
8363	}
8364	};
8365
8366	inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
8367	flatbuffers::FlatBufferBuilder &_fbb) {
8368	LogicalAndOptionsBuilder builder_(_fbb);
8369	return builder_.Finish();
8370	}
8371
8372	flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8373
8374	struct LogicalNotOptionsT : public flatbuffers::NativeTable {
8375	typedef LogicalNotOptions TableType;
8376	LogicalNotOptionsT() {
8377	}
8378	};
8379
8380	struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8381	typedef LogicalNotOptionsT NativeTableType;
8382	bool Verify(flatbuffers::Verifier &verifier) const {
8383	return VerifyTableStart(verifier) &&
8384	verifier.EndTable();
8385	}
8386	LogicalNotOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8387	void UnPackTo(LogicalNotOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8388	static flatbuffers::Offset<LogicalNotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8389	};
8390
8391	struct LogicalNotOptionsBuilder {
8392	flatbuffers::FlatBufferBuilder &fbb_;
8393	flatbuffers::uoffset_t start_;
8394	explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8395	: fbb_(_fbb) {
8396	start_ = fbb_.StartTable();
8397	}
8398	LogicalNotOptionsBuilder &operator=(const LogicalNotOptionsBuilder &);
8399	flatbuffers::Offset<LogicalNotOptions> Finish() {
8400	const auto end = fbb_.EndTable(start_);
8401	auto o = flatbuffers::Offset<LogicalNotOptions>(end);
8402	return o;
8403	}
8404	};
8405
8406	inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
8407	flatbuffers::FlatBufferBuilder &_fbb) {
8408	LogicalNotOptionsBuilder builder_(_fbb);
8409	return builder_.Finish();
8410	}
8411
8412	flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8413
8414	struct UnpackOptionsT : public flatbuffers::NativeTable {
8415	typedef UnpackOptions TableType;
8416	int32_t num;
8417	int32_t axis;
8418	UnpackOptionsT()
8419	: num(`0`),
8420	axis(`0`) {
8421	}
8422	};
8423
8424	struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8425	typedef UnpackOptionsT NativeTableType;
8426	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8427	VT_NUM = `4`,
8428	VT_AXIS = `6`
8429	};
8430	int32_t num() const {
8431	return GetField<int32_t>(VT_NUM, `0`);
8432	}
8433	int32_t axis() const {
8434	return GetField<int32_t>(VT_AXIS, `0`);
8435	}
8436	bool Verify(flatbuffers::Verifier &verifier) const {
8437	return VerifyTableStart(verifier) &&
8438	VerifyField<int32_t>(verifier, VT_NUM) &&
8439	VerifyField<int32_t>(verifier, VT_AXIS) &&
8440	verifier.EndTable();
8441	}
8442	UnpackOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8443	void UnPackTo(UnpackOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8444	static flatbuffers::Offset<UnpackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8445	};
8446
8447	struct UnpackOptionsBuilder {
8448	flatbuffers::FlatBufferBuilder &fbb_;
8449	flatbuffers::uoffset_t start_;
8450	void add_num(int32_t num) {
8451	fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, `0`);
8452	}
8453	void add_axis(int32_t axis) {
8454	fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, `0`);
8455	}
8456	explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8457	: fbb_(_fbb) {
8458	start_ = fbb_.StartTable();
8459	}
8460	UnpackOptionsBuilder &operator=(const UnpackOptionsBuilder &);
8461	flatbuffers::Offset<UnpackOptions> Finish() {
8462	const auto end = fbb_.EndTable(start_);
8463	auto o = flatbuffers::Offset<UnpackOptions>(end);
8464	return o;
8465	}
8466	};
8467
8468	inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
8469	flatbuffers::FlatBufferBuilder &_fbb,
8470	int32_t num = `0`,
8471	int32_t axis = `0`) {
8472	UnpackOptionsBuilder builder_(_fbb);
8473	builder_.add_axis(axis);
8474	builder_.add_num(num);
8475	return builder_.Finish();
8476	}
8477
8478	flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8479
8480	struct FloorDivOptionsT : public flatbuffers::NativeTable {
8481	typedef FloorDivOptions TableType;
8482	FloorDivOptionsT() {
8483	}
8484	};
8485
8486	struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8487	typedef FloorDivOptionsT NativeTableType;
8488	bool Verify(flatbuffers::Verifier &verifier) const {
8489	return VerifyTableStart(verifier) &&
8490	verifier.EndTable();
8491	}
8492	FloorDivOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8493	void UnPackTo(FloorDivOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8494	static flatbuffers::Offset<FloorDivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8495	};
8496
8497	struct FloorDivOptionsBuilder {
8498	flatbuffers::FlatBufferBuilder &fbb_;
8499	flatbuffers::uoffset_t start_;
8500	explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8501	: fbb_(_fbb) {
8502	start_ = fbb_.StartTable();
8503	}
8504	FloorDivOptionsBuilder &operator=(const FloorDivOptionsBuilder &);
8505	flatbuffers::Offset<FloorDivOptions> Finish() {
8506	const auto end = fbb_.EndTable(start_);
8507	auto o = flatbuffers::Offset<FloorDivOptions>(end);
8508	return o;
8509	}
8510	};
8511
8512	inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
8513	flatbuffers::FlatBufferBuilder &_fbb) {
8514	FloorDivOptionsBuilder builder_(_fbb);
8515	return builder_.Finish();
8516	}
8517
8518	flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8519
8520	struct SquareOptionsT : public flatbuffers::NativeTable {
8521	typedef SquareOptions TableType;
8522	SquareOptionsT() {
8523	}
8524	};
8525
8526	struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8527	typedef SquareOptionsT NativeTableType;
8528	bool Verify(flatbuffers::Verifier &verifier) const {
8529	return VerifyTableStart(verifier) &&
8530	verifier.EndTable();
8531	}
8532	SquareOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8533	void UnPackTo(SquareOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8534	static flatbuffers::Offset<SquareOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8535	};
8536
8537	struct SquareOptionsBuilder {
8538	flatbuffers::FlatBufferBuilder &fbb_;
8539	flatbuffers::uoffset_t start_;
8540	explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8541	: fbb_(_fbb) {
8542	start_ = fbb_.StartTable();
8543	}
8544	SquareOptionsBuilder &operator=(const SquareOptionsBuilder &);
8545	flatbuffers::Offset<SquareOptions> Finish() {
8546	const auto end = fbb_.EndTable(start_);
8547	auto o = flatbuffers::Offset<SquareOptions>(end);
8548	return o;
8549	}
8550	};
8551
8552	inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(
8553	flatbuffers::FlatBufferBuilder &_fbb) {
8554	SquareOptionsBuilder builder_(_fbb);
8555	return builder_.Finish();
8556	}
8557
8558	flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8559
8560	struct ZerosLikeOptionsT : public flatbuffers::NativeTable {
8561	typedef ZerosLikeOptions TableType;
8562	ZerosLikeOptionsT() {
8563	}
8564	};
8565
8566	struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8567	typedef ZerosLikeOptionsT NativeTableType;
8568	bool Verify(flatbuffers::Verifier &verifier) const {
8569	return VerifyTableStart(verifier) &&
8570	verifier.EndTable();
8571	}
8572	ZerosLikeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8573	void UnPackTo(ZerosLikeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8574	static flatbuffers::Offset<ZerosLikeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8575	};
8576
8577	struct ZerosLikeOptionsBuilder {
8578	flatbuffers::FlatBufferBuilder &fbb_;
8579	flatbuffers::uoffset_t start_;
8580	explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8581	: fbb_(_fbb) {
8582	start_ = fbb_.StartTable();
8583	}
8584	ZerosLikeOptionsBuilder &operator=(const ZerosLikeOptionsBuilder &);
8585	flatbuffers::Offset<ZerosLikeOptions> Finish() {
8586	const auto end = fbb_.EndTable(start_);
8587	auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
8588	return o;
8589	}
8590	};
8591
8592	inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
8593	flatbuffers::FlatBufferBuilder &_fbb) {
8594	ZerosLikeOptionsBuilder builder_(_fbb);
8595	return builder_.Finish();
8596	}
8597
8598	flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8599
8600	struct FillOptionsT : public flatbuffers::NativeTable {
8601	typedef FillOptions TableType;
8602	FillOptionsT() {
8603	}
8604	};
8605
8606	struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8607	typedef FillOptionsT NativeTableType;
8608	bool Verify(flatbuffers::Verifier &verifier) const {
8609	return VerifyTableStart(verifier) &&
8610	verifier.EndTable();
8611	}
8612	FillOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8613	void UnPackTo(FillOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8614	static flatbuffers::Offset<FillOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8615	};
8616
8617	struct FillOptionsBuilder {
8618	flatbuffers::FlatBufferBuilder &fbb_;
8619	flatbuffers::uoffset_t start_;
8620	explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8621	: fbb_(_fbb) {
8622	start_ = fbb_.StartTable();
8623	}
8624	FillOptionsBuilder &operator=(const FillOptionsBuilder &);
8625	flatbuffers::Offset<FillOptions> Finish() {
8626	const auto end = fbb_.EndTable(start_);
8627	auto o = flatbuffers::Offset<FillOptions>(end);
8628	return o;
8629	}
8630	};
8631
8632	inline flatbuffers::Offset<FillOptions> CreateFillOptions(
8633	flatbuffers::FlatBufferBuilder &_fbb) {
8634	FillOptionsBuilder builder_(_fbb);
8635	return builder_.Finish();
8636	}
8637
8638	flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8639
8640	struct FloorModOptionsT : public flatbuffers::NativeTable {
8641	typedef FloorModOptions TableType;
8642	FloorModOptionsT() {
8643	}
8644	};
8645
8646	struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8647	typedef FloorModOptionsT NativeTableType;
8648	bool Verify(flatbuffers::Verifier &verifier) const {
8649	return VerifyTableStart(verifier) &&
8650	verifier.EndTable();
8651	}
8652	FloorModOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8653	void UnPackTo(FloorModOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8654	static flatbuffers::Offset<FloorModOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8655	};
8656
8657	struct FloorModOptionsBuilder {
8658	flatbuffers::FlatBufferBuilder &fbb_;
8659	flatbuffers::uoffset_t start_;
8660	explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8661	: fbb_(_fbb) {
8662	start_ = fbb_.StartTable();
8663	}
8664	FloorModOptionsBuilder &operator=(const FloorModOptionsBuilder &);
8665	flatbuffers::Offset<FloorModOptions> Finish() {
8666	const auto end = fbb_.EndTable(start_);
8667	auto o = flatbuffers::Offset<FloorModOptions>(end);
8668	return o;
8669	}
8670	};
8671
8672	inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
8673	flatbuffers::FlatBufferBuilder &_fbb) {
8674	FloorModOptionsBuilder builder_(_fbb);
8675	return builder_.Finish();
8676	}
8677
8678	flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8679
8680	struct RangeOptionsT : public flatbuffers::NativeTable {
8681	typedef RangeOptions TableType;
8682	RangeOptionsT() {
8683	}
8684	};
8685
8686	struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8687	typedef RangeOptionsT NativeTableType;
8688	bool Verify(flatbuffers::Verifier &verifier) const {
8689	return VerifyTableStart(verifier) &&
8690	verifier.EndTable();
8691	}
8692	RangeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8693	void UnPackTo(RangeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8694	static flatbuffers::Offset<RangeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8695	};
8696
8697	struct RangeOptionsBuilder {
8698	flatbuffers::FlatBufferBuilder &fbb_;
8699	flatbuffers::uoffset_t start_;
8700	explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8701	: fbb_(_fbb) {
8702	start_ = fbb_.StartTable();
8703	}
8704	RangeOptionsBuilder &operator=(const RangeOptionsBuilder &);
8705	flatbuffers::Offset<RangeOptions> Finish() {
8706	const auto end = fbb_.EndTable(start_);
8707	auto o = flatbuffers::Offset<RangeOptions>(end);
8708	return o;
8709	}
8710	};
8711
8712	inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(
8713	flatbuffers::FlatBufferBuilder &_fbb) {
8714	RangeOptionsBuilder builder_(_fbb);
8715	return builder_.Finish();
8716	}
8717
8718	flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8719
8720	struct LeakyReluOptionsT : public flatbuffers::NativeTable {
8721	typedef LeakyReluOptions TableType;
8722	float alpha;
8723	LeakyReluOptionsT()
8724	: alpha(`0.0f`) {
8725	}
8726	};
8727
8728	struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8729	typedef LeakyReluOptionsT NativeTableType;
8730	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8731	VT_ALPHA = `4`
8732	};
8733	float alpha() const {
8734	return GetField<float>(VT_ALPHA, `0.0f`);
8735	}
8736	bool Verify(flatbuffers::Verifier &verifier) const {
8737	return VerifyTableStart(verifier) &&
8738	VerifyField<float>(verifier, VT_ALPHA) &&
8739	verifier.EndTable();
8740	}
8741	LeakyReluOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8742	void UnPackTo(LeakyReluOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8743	static flatbuffers::Offset<LeakyReluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8744	};
8745
8746	struct LeakyReluOptionsBuilder {
8747	flatbuffers::FlatBufferBuilder &fbb_;
8748	flatbuffers::uoffset_t start_;
8749	void add_alpha(float alpha) {
8750	fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, `0.0f`);
8751	}
8752	explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8753	: fbb_(_fbb) {
8754	start_ = fbb_.StartTable();
8755	}
8756	LeakyReluOptionsBuilder &operator=(const LeakyReluOptionsBuilder &);
8757	flatbuffers::Offset<LeakyReluOptions> Finish() {
8758	const auto end = fbb_.EndTable(start_);
8759	auto o = flatbuffers::Offset<LeakyReluOptions>(end);
8760	return o;
8761	}
8762	};
8763
8764	inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
8765	flatbuffers::FlatBufferBuilder &_fbb,
8766	float alpha = `0.0f`) {
8767	LeakyReluOptionsBuilder builder_(_fbb);
8768	builder_.add_alpha(alpha);
8769	return builder_.Finish();
8770	}
8771
8772	flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8773
8774	struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable {
8775	typedef SquaredDifferenceOptions TableType;
8776	SquaredDifferenceOptionsT() {
8777	}
8778	};
8779
8780	struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8781	typedef SquaredDifferenceOptionsT NativeTableType;
8782	bool Verify(flatbuffers::Verifier &verifier) const {
8783	return VerifyTableStart(verifier) &&
8784	verifier.EndTable();
8785	}
8786	SquaredDifferenceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8787	void UnPackTo(SquaredDifferenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8788	static flatbuffers::Offset<SquaredDifferenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8789	};
8790
8791	struct SquaredDifferenceOptionsBuilder {
8792	flatbuffers::FlatBufferBuilder &fbb_;
8793	flatbuffers::uoffset_t start_;
8794	explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8795	: fbb_(_fbb) {
8796	start_ = fbb_.StartTable();
8797	}
8798	SquaredDifferenceOptionsBuilder &operator=(const SquaredDifferenceOptionsBuilder &);
8799	flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
8800	const auto end = fbb_.EndTable(start_);
8801	auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
8802	return o;
8803	}
8804	};
8805
8806	inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
8807	flatbuffers::FlatBufferBuilder &_fbb) {
8808	SquaredDifferenceOptionsBuilder builder_(_fbb);
8809	return builder_.Finish();
8810	}
8811
8812	flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8813
8814	struct MirrorPadOptionsT : public flatbuffers::NativeTable {
8815	typedef MirrorPadOptions TableType;
8816	tflite::MirrorPadMode mode;
8817	MirrorPadOptionsT()
8818	: mode(tflite::MirrorPadMode_REFLECT) {
8819	}
8820	};
8821
8822	struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8823	typedef MirrorPadOptionsT NativeTableType;
8824	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8825	VT_MODE = `4`
8826	};
8827	tflite::MirrorPadMode mode() const {
8828	return static_cast<tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, `0`));
8829	}
8830	bool Verify(flatbuffers::Verifier &verifier) const {
8831	return VerifyTableStart(verifier) &&
8832	VerifyField<int8_t>(verifier, VT_MODE) &&
8833	verifier.EndTable();
8834	}
8835	MirrorPadOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8836	void UnPackTo(MirrorPadOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8837	static flatbuffers::Offset<MirrorPadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8838	};
8839
8840	struct MirrorPadOptionsBuilder {
8841	flatbuffers::FlatBufferBuilder &fbb_;
8842	flatbuffers::uoffset_t start_;
8843	void add_mode(tflite::MirrorPadMode mode) {
8844	fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), `0`);
8845	}
8846	explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8847	: fbb_(_fbb) {
8848	start_ = fbb_.StartTable();
8849	}
8850	MirrorPadOptionsBuilder &operator=(const MirrorPadOptionsBuilder &);
8851	flatbuffers::Offset<MirrorPadOptions> Finish() {
8852	const auto end = fbb_.EndTable(start_);
8853	auto o = flatbuffers::Offset<MirrorPadOptions>(end);
8854	return o;
8855	}
8856	};
8857
8858	inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
8859	flatbuffers::FlatBufferBuilder &_fbb,
8860	tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT) {
8861	MirrorPadOptionsBuilder builder_(_fbb);
8862	builder_.add_mode(mode);
8863	return builder_.Finish();
8864	}
8865
8866	flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8867
8868	struct UniqueOptionsT : public flatbuffers::NativeTable {
8869	typedef UniqueOptions TableType;
8870	tflite::TensorType idx_out_type;
8871	UniqueOptionsT()
8872	: idx_out_type(tflite::TensorType_INT32) {
8873	}
8874	};
8875
8876	struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8877	typedef UniqueOptionsT NativeTableType;
8878	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8879	VT_IDX_OUT_TYPE = `4`
8880	};
8881	tflite::TensorType idx_out_type() const {
8882	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, `2`));
8883	}
8884	bool Verify(flatbuffers::Verifier &verifier) const {
8885	return VerifyTableStart(verifier) &&
8886	VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
8887	verifier.EndTable();
8888	}
8889	UniqueOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8890	void UnPackTo(UniqueOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8891	static flatbuffers::Offset<UniqueOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8892	};
8893
8894	struct UniqueOptionsBuilder {
8895	flatbuffers::FlatBufferBuilder &fbb_;
8896	flatbuffers::uoffset_t start_;
8897	void add_idx_out_type(tflite::TensorType idx_out_type) {
8898	fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), `2`);
8899	}
8900	explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8901	: fbb_(_fbb) {
8902	start_ = fbb_.StartTable();
8903	}
8904	UniqueOptionsBuilder &operator=(const UniqueOptionsBuilder &);
8905	flatbuffers::Offset<UniqueOptions> Finish() {
8906	const auto end = fbb_.EndTable(start_);
8907	auto o = flatbuffers::Offset<UniqueOptions>(end);
8908	return o;
8909	}
8910	};
8911
8912	inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
8913	flatbuffers::FlatBufferBuilder &_fbb,
8914	tflite::TensorType idx_out_type = tflite::TensorType_INT32) {
8915	UniqueOptionsBuilder builder_(_fbb);
8916	builder_.add_idx_out_type(idx_out_type);
8917	return builder_.Finish();
8918	}
8919
8920	flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8921
8922	struct ReverseV2OptionsT : public flatbuffers::NativeTable {
8923	typedef ReverseV2Options TableType;
8924	ReverseV2OptionsT() {
8925	}
8926	};
8927
8928	struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8929	typedef ReverseV2OptionsT NativeTableType;
8930	bool Verify(flatbuffers::Verifier &verifier) const {
8931	return VerifyTableStart(verifier) &&
8932	verifier.EndTable();
8933	}
8934	ReverseV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8935	void UnPackTo(ReverseV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8936	static flatbuffers::Offset<ReverseV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8937	};
8938
8939	struct ReverseV2OptionsBuilder {
8940	flatbuffers::FlatBufferBuilder &fbb_;
8941	flatbuffers::uoffset_t start_;
8942	explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8943	: fbb_(_fbb) {
8944	start_ = fbb_.StartTable();
8945	}
8946	ReverseV2OptionsBuilder &operator=(const ReverseV2OptionsBuilder &);
8947	flatbuffers::Offset<ReverseV2Options> Finish() {
8948	const auto end = fbb_.EndTable(start_);
8949	auto o = flatbuffers::Offset<ReverseV2Options>(end);
8950	return o;
8951	}
8952	};
8953
8954	inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
8955	flatbuffers::FlatBufferBuilder &_fbb) {
8956	ReverseV2OptionsBuilder builder_(_fbb);
8957	return builder_.Finish();
8958	}
8959
8960	flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8961
8962	struct AddNOptionsT : public flatbuffers::NativeTable {
8963	typedef AddNOptions TableType;
8964	AddNOptionsT() {
8965	}
8966	};
8967
8968	struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8969	typedef AddNOptionsT NativeTableType;
8970	bool Verify(flatbuffers::Verifier &verifier) const {
8971	return VerifyTableStart(verifier) &&
8972	verifier.EndTable();
8973	}
8974	AddNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8975	void UnPackTo(AddNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8976	static flatbuffers::Offset<AddNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8977	};
8978
8979	struct AddNOptionsBuilder {
8980	flatbuffers::FlatBufferBuilder &fbb_;
8981	flatbuffers::uoffset_t start_;
8982	explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8983	: fbb_(_fbb) {
8984	start_ = fbb_.StartTable();
8985	}
8986	AddNOptionsBuilder &operator=(const AddNOptionsBuilder &);
8987	flatbuffers::Offset<AddNOptions> Finish() {
8988	const auto end = fbb_.EndTable(start_);
8989	auto o = flatbuffers::Offset<AddNOptions>(end);
8990	return o;
8991	}
8992	};
8993
8994	inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(
8995	flatbuffers::FlatBufferBuilder &_fbb) {
8996	AddNOptionsBuilder builder_(_fbb);
8997	return builder_.Finish();
8998	}
8999
9000	flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9001
9002	struct GatherNdOptionsT : public flatbuffers::NativeTable {
9003	typedef GatherNdOptions TableType;
9004	GatherNdOptionsT() {
9005	}
9006	};
9007
9008	struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9009	typedef GatherNdOptionsT NativeTableType;
9010	bool Verify(flatbuffers::Verifier &verifier) const {
9011	return VerifyTableStart(verifier) &&
9012	verifier.EndTable();
9013	}
9014	GatherNdOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9015	void UnPackTo(GatherNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9016	static flatbuffers::Offset<GatherNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9017	};
9018
9019	struct GatherNdOptionsBuilder {
9020	flatbuffers::FlatBufferBuilder &fbb_;
9021	flatbuffers::uoffset_t start_;
9022	explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9023	: fbb_(_fbb) {
9024	start_ = fbb_.StartTable();
9025	}
9026	GatherNdOptionsBuilder &operator=(const GatherNdOptionsBuilder &);
9027	flatbuffers::Offset<GatherNdOptions> Finish() {
9028	const auto end = fbb_.EndTable(start_);
9029	auto o = flatbuffers::Offset<GatherNdOptions>(end);
9030	return o;
9031	}
9032	};
9033
9034	inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
9035	flatbuffers::FlatBufferBuilder &_fbb) {
9036	GatherNdOptionsBuilder builder_(_fbb);
9037	return builder_.Finish();
9038	}
9039
9040	flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9041
9042	struct WhereOptionsT : public flatbuffers::NativeTable {
9043	typedef WhereOptions TableType;
9044	WhereOptionsT() {
9045	}
9046	};
9047
9048	struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9049	typedef WhereOptionsT NativeTableType;
9050	bool Verify(flatbuffers::Verifier &verifier) const {
9051	return VerifyTableStart(verifier) &&
9052	verifier.EndTable();
9053	}
9054	WhereOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9055	void UnPackTo(WhereOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9056	static flatbuffers::Offset<WhereOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9057	};
9058
9059	struct WhereOptionsBuilder {
9060	flatbuffers::FlatBufferBuilder &fbb_;
9061	flatbuffers::uoffset_t start_;
9062	explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9063	: fbb_(_fbb) {
9064	start_ = fbb_.StartTable();
9065	}
9066	WhereOptionsBuilder &operator=(const WhereOptionsBuilder &);
9067	flatbuffers::Offset<WhereOptions> Finish() {
9068	const auto end = fbb_.EndTable(start_);
9069	auto o = flatbuffers::Offset<WhereOptions>(end);
9070	return o;
9071	}
9072	};
9073
9074	inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(
9075	flatbuffers::FlatBufferBuilder &_fbb) {
9076	WhereOptionsBuilder builder_(_fbb);
9077	return builder_.Finish();
9078	}
9079
9080	flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9081
9082	struct ReverseSequenceOptionsT : public flatbuffers::NativeTable {
9083	typedef ReverseSequenceOptions TableType;
9084	int32_t seq_dim;
9085	int32_t batch_dim;
9086	ReverseSequenceOptionsT()
9087	: seq_dim(`0`),
9088	batch_dim(`0`) {
9089	}
9090	};
9091
9092	struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9093	typedef ReverseSequenceOptionsT NativeTableType;
9094	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9095	VT_SEQ_DIM = `4`,
9096	VT_BATCH_DIM = `6`
9097	};
9098	int32_t seq_dim() const {
9099	return GetField<int32_t>(VT_SEQ_DIM, `0`);
9100	}
9101	int32_t batch_dim() const {
9102	return GetField<int32_t>(VT_BATCH_DIM, `0`);
9103	}
9104	bool Verify(flatbuffers::Verifier &verifier) const {
9105	return VerifyTableStart(verifier) &&
9106	VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
9107	VerifyField<int32_t>(verifier, VT_BATCH_DIM) &&
9108	verifier.EndTable();
9109	}
9110	ReverseSequenceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9111	void UnPackTo(ReverseSequenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9112	static flatbuffers::Offset<ReverseSequenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9113	};
9114
9115	struct ReverseSequenceOptionsBuilder {
9116	flatbuffers::FlatBufferBuilder &fbb_;
9117	flatbuffers::uoffset_t start_;
9118	void add_seq_dim(int32_t seq_dim) {
9119	fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, `0`);
9120	}
9121	void add_batch_dim(int32_t batch_dim) {
9122	fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, `0`);
9123	}
9124	explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9125	: fbb_(_fbb) {
9126	start_ = fbb_.StartTable();
9127	}
9128	ReverseSequenceOptionsBuilder &operator=(const ReverseSequenceOptionsBuilder &);
9129	flatbuffers::Offset<ReverseSequenceOptions> Finish() {
9130	const auto end = fbb_.EndTable(start_);
9131	auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
9132	return o;
9133	}
9134	};
9135
9136	inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
9137	flatbuffers::FlatBufferBuilder &_fbb,
9138	int32_t seq_dim = `0`,
9139	int32_t batch_dim = `0`) {
9140	ReverseSequenceOptionsBuilder builder_(_fbb);
9141	builder_.add_batch_dim(batch_dim);
9142	builder_.add_seq_dim(seq_dim);
9143	return builder_.Finish();
9144	}
9145
9146	flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9147
9148	struct MatrixDiagOptionsT : public flatbuffers::NativeTable {
9149	typedef MatrixDiagOptions TableType;
9150	MatrixDiagOptionsT() {
9151	}
9152	};
9153
9154	struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9155	typedef MatrixDiagOptionsT NativeTableType;
9156	bool Verify(flatbuffers::Verifier &verifier) const {
9157	return VerifyTableStart(verifier) &&
9158	verifier.EndTable();
9159	}
9160	MatrixDiagOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9161	void UnPackTo(MatrixDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9162	static flatbuffers::Offset<MatrixDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9163	};
9164
9165	struct MatrixDiagOptionsBuilder {
9166	flatbuffers::FlatBufferBuilder &fbb_;
9167	flatbuffers::uoffset_t start_;
9168	explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9169	: fbb_(_fbb) {
9170	start_ = fbb_.StartTable();
9171	}
9172	MatrixDiagOptionsBuilder &operator=(const MatrixDiagOptionsBuilder &);
9173	flatbuffers::Offset<MatrixDiagOptions> Finish() {
9174	const auto end = fbb_.EndTable(start_);
9175	auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
9176	return o;
9177	}
9178	};
9179
9180	inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
9181	flatbuffers::FlatBufferBuilder &_fbb) {
9182	MatrixDiagOptionsBuilder builder_(_fbb);
9183	return builder_.Finish();
9184	}
9185
9186	flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9187
9188	struct QuantizeOptionsT : public flatbuffers::NativeTable {
9189	typedef QuantizeOptions TableType;
9190	QuantizeOptionsT() {
9191	}
9192	};
9193
9194	struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9195	typedef QuantizeOptionsT NativeTableType;
9196	bool Verify(flatbuffers::Verifier &verifier) const {
9197	return VerifyTableStart(verifier) &&
9198	verifier.EndTable();
9199	}
9200	QuantizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9201	void UnPackTo(QuantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9202	static flatbuffers::Offset<QuantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9203	};
9204
9205	struct QuantizeOptionsBuilder {
9206	flatbuffers::FlatBufferBuilder &fbb_;
9207	flatbuffers::uoffset_t start_;
9208	explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9209	: fbb_(_fbb) {
9210	start_ = fbb_.StartTable();
9211	}
9212	QuantizeOptionsBuilder &operator=(const QuantizeOptionsBuilder &);
9213	flatbuffers::Offset<QuantizeOptions> Finish() {
9214	const auto end = fbb_.EndTable(start_);
9215	auto o = flatbuffers::Offset<QuantizeOptions>(end);
9216	return o;
9217	}
9218	};
9219
9220	inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
9221	flatbuffers::FlatBufferBuilder &_fbb) {
9222	QuantizeOptionsBuilder builder_(_fbb);
9223	return builder_.Finish();
9224	}
9225
9226	flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9227
9228	struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable {
9229	typedef MatrixSetDiagOptions TableType;
9230	MatrixSetDiagOptionsT() {
9231	}
9232	};
9233
9234	struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9235	typedef MatrixSetDiagOptionsT NativeTableType;
9236	bool Verify(flatbuffers::Verifier &verifier) const {
9237	return VerifyTableStart(verifier) &&
9238	verifier.EndTable();
9239	}
9240	MatrixSetDiagOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9241	void UnPackTo(MatrixSetDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9242	static flatbuffers::Offset<MatrixSetDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9243	};
9244
9245	struct MatrixSetDiagOptionsBuilder {
9246	flatbuffers::FlatBufferBuilder &fbb_;
9247	flatbuffers::uoffset_t start_;
9248	explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9249	: fbb_(_fbb) {
9250	start_ = fbb_.StartTable();
9251	}
9252	MatrixSetDiagOptionsBuilder &operator=(const MatrixSetDiagOptionsBuilder &);
9253	flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
9254	const auto end = fbb_.EndTable(start_);
9255	auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
9256	return o;
9257	}
9258	};
9259
9260	inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
9261	flatbuffers::FlatBufferBuilder &_fbb) {
9262	MatrixSetDiagOptionsBuilder builder_(_fbb);
9263	return builder_.Finish();
9264	}
9265
9266	flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9267
9268	struct IfOptionsT : public flatbuffers::NativeTable {
9269	typedef IfOptions TableType;
9270	int32_t then_subgraph_index;
9271	int32_t else_subgraph_index;
9272	IfOptionsT()
9273	: then_subgraph_index(`0`),
9274	else_subgraph_index(`0`) {
9275	}
9276	};
9277
9278	struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9279	typedef IfOptionsT NativeTableType;
9280	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9281	VT_THEN_SUBGRAPH_INDEX = `4`,
9282	VT_ELSE_SUBGRAPH_INDEX = `6`
9283	};
9284	int32_t then_subgraph_index() const {
9285	return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, `0`);
9286	}
9287	int32_t else_subgraph_index() const {
9288	return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, `0`);
9289	}
9290	bool Verify(flatbuffers::Verifier &verifier) const {
9291	return VerifyTableStart(verifier) &&
9292	VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
9293	VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) &&
9294	verifier.EndTable();
9295	}
9296	IfOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9297	void UnPackTo(IfOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9298	static flatbuffers::Offset<IfOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9299	};
9300
9301	struct IfOptionsBuilder {
9302	flatbuffers::FlatBufferBuilder &fbb_;
9303	flatbuffers::uoffset_t start_;
9304	void add_then_subgraph_index(int32_t then_subgraph_index) {
9305	fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, `0`);
9306	}
9307	void add_else_subgraph_index(int32_t else_subgraph_index) {
9308	fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, `0`);
9309	}
9310	explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9311	: fbb_(_fbb) {
9312	start_ = fbb_.StartTable();
9313	}
9314	IfOptionsBuilder &operator=(const IfOptionsBuilder &);
9315	flatbuffers::Offset<IfOptions> Finish() {
9316	const auto end = fbb_.EndTable(start_);
9317	auto o = flatbuffers::Offset<IfOptions>(end);
9318	return o;
9319	}
9320	};
9321
9322	inline flatbuffers::Offset<IfOptions> CreateIfOptions(
9323	flatbuffers::FlatBufferBuilder &_fbb,
9324	int32_t then_subgraph_index = `0`,
9325	int32_t else_subgraph_index = `0`) {
9326	IfOptionsBuilder builder_(_fbb);
9327	builder_.add_else_subgraph_index(else_subgraph_index);
9328	builder_.add_then_subgraph_index(then_subgraph_index);
9329	return builder_.Finish();
9330	}
9331
9332	flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9333
9334	struct CallOnceOptionsT : public flatbuffers::NativeTable {
9335	typedef CallOnceOptions TableType;
9336	int32_t init_subgraph_index;
9337	CallOnceOptionsT()
9338	: init_subgraph_index(`0`) {
9339	}
9340	};
9341
9342	struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9343	typedef CallOnceOptionsT NativeTableType;
9344	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9345	VT_INIT_SUBGRAPH_INDEX = `4`
9346	};
9347	int32_t init_subgraph_index() const {
9348	return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, `0`);
9349	}
9350	bool Verify(flatbuffers::Verifier &verifier) const {
9351	return VerifyTableStart(verifier) &&
9352	VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX) &&
9353	verifier.EndTable();
9354	}
9355	CallOnceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9356	void UnPackTo(CallOnceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9357	static flatbuffers::Offset<CallOnceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9358	};
9359
9360	struct CallOnceOptionsBuilder {
9361	flatbuffers::FlatBufferBuilder &fbb_;
9362	flatbuffers::uoffset_t start_;
9363	void add_init_subgraph_index(int32_t init_subgraph_index) {
9364	fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, `0`);
9365	}
9366	explicit CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9367	: fbb_(_fbb) {
9368	start_ = fbb_.StartTable();
9369	}
9370	CallOnceOptionsBuilder &operator=(const CallOnceOptionsBuilder &);
9371	flatbuffers::Offset<CallOnceOptions> Finish() {
9372	const auto end = fbb_.EndTable(start_);
9373	auto o = flatbuffers::Offset<CallOnceOptions>(end);
9374	return o;
9375	}
9376	};
9377
9378	inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(
9379	flatbuffers::FlatBufferBuilder &_fbb,
9380	int32_t init_subgraph_index = `0`) {
9381	CallOnceOptionsBuilder builder_(_fbb);
9382	builder_.add_init_subgraph_index(init_subgraph_index);
9383	return builder_.Finish();
9384	}
9385
9386	flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9387
9388	struct WhileOptionsT : public flatbuffers::NativeTable {
9389	typedef WhileOptions TableType;
9390	int32_t cond_subgraph_index;
9391	int32_t body_subgraph_index;
9392	WhileOptionsT()
9393	: cond_subgraph_index(`0`),
9394	body_subgraph_index(`0`) {
9395	}
9396	};
9397
9398	struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9399	typedef WhileOptionsT NativeTableType;
9400	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9401	VT_COND_SUBGRAPH_INDEX = `4`,
9402	VT_BODY_SUBGRAPH_INDEX = `6`
9403	};
9404	int32_t cond_subgraph_index() const {
9405	return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, `0`);
9406	}
9407	int32_t body_subgraph_index() const {
9408	return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, `0`);
9409	}
9410	bool Verify(flatbuffers::Verifier &verifier) const {
9411	return VerifyTableStart(verifier) &&
9412	VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
9413	VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) &&
9414	verifier.EndTable();
9415	}
9416	WhileOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9417	void UnPackTo(WhileOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9418	static flatbuffers::Offset<WhileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9419	};
9420
9421	struct WhileOptionsBuilder {
9422	flatbuffers::FlatBufferBuilder &fbb_;
9423	flatbuffers::uoffset_t start_;
9424	void add_cond_subgraph_index(int32_t cond_subgraph_index) {
9425	fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, `0`);
9426	}
9427	void add_body_subgraph_index(int32_t body_subgraph_index) {
9428	fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, `0`);
9429	}
9430	explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9431	: fbb_(_fbb) {
9432	start_ = fbb_.StartTable();
9433	}
9434	WhileOptionsBuilder &operator=(const WhileOptionsBuilder &);
9435	flatbuffers::Offset<WhileOptions> Finish() {
9436	const auto end = fbb_.EndTable(start_);
9437	auto o = flatbuffers::Offset<WhileOptions>(end);
9438	return o;
9439	}
9440	};
9441
9442	inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(
9443	flatbuffers::FlatBufferBuilder &_fbb,
9444	int32_t cond_subgraph_index = `0`,
9445	int32_t body_subgraph_index = `0`) {
9446	WhileOptionsBuilder builder_(_fbb);
9447	builder_.add_body_subgraph_index(body_subgraph_index);
9448	builder_.add_cond_subgraph_index(cond_subgraph_index);
9449	return builder_.Finish();
9450	}
9451
9452	flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9453
9454	struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable {
9455	typedef NonMaxSuppressionV4Options TableType;
9456	NonMaxSuppressionV4OptionsT() {
9457	}
9458	};
9459
9460	struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9461	typedef NonMaxSuppressionV4OptionsT NativeTableType;
9462	bool Verify(flatbuffers::Verifier &verifier) const {
9463	return VerifyTableStart(verifier) &&
9464	verifier.EndTable();
9465	}
9466	NonMaxSuppressionV4OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9467	void UnPackTo(NonMaxSuppressionV4OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9468	static flatbuffers::Offset<NonMaxSuppressionV4Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9469	};
9470
9471	struct NonMaxSuppressionV4OptionsBuilder {
9472	flatbuffers::FlatBufferBuilder &fbb_;
9473	flatbuffers::uoffset_t start_;
9474	explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9475	: fbb_(_fbb) {
9476	start_ = fbb_.StartTable();
9477	}
9478	NonMaxSuppressionV4OptionsBuilder &operator=(const NonMaxSuppressionV4OptionsBuilder &);
9479	flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
9480	const auto end = fbb_.EndTable(start_);
9481	auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
9482	return o;
9483	}
9484	};
9485
9486	inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
9487	flatbuffers::FlatBufferBuilder &_fbb) {
9488	NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
9489	return builder_.Finish();
9490	}
9491
9492	flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9493
9494	struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable {
9495	typedef NonMaxSuppressionV5Options TableType;
9496	NonMaxSuppressionV5OptionsT() {
9497	}
9498	};
9499
9500	struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9501	typedef NonMaxSuppressionV5OptionsT NativeTableType;
9502	bool Verify(flatbuffers::Verifier &verifier) const {
9503	return VerifyTableStart(verifier) &&
9504	verifier.EndTable();
9505	}
9506	NonMaxSuppressionV5OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9507	void UnPackTo(NonMaxSuppressionV5OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9508	static flatbuffers::Offset<NonMaxSuppressionV5Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9509	};
9510
9511	struct NonMaxSuppressionV5OptionsBuilder {
9512	flatbuffers::FlatBufferBuilder &fbb_;
9513	flatbuffers::uoffset_t start_;
9514	explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9515	: fbb_(_fbb) {
9516	start_ = fbb_.StartTable();
9517	}
9518	NonMaxSuppressionV5OptionsBuilder &operator=(const NonMaxSuppressionV5OptionsBuilder &);
9519	flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
9520	const auto end = fbb_.EndTable(start_);
9521	auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
9522	return o;
9523	}
9524	};
9525
9526	inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
9527	flatbuffers::FlatBufferBuilder &_fbb) {
9528	NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
9529	return builder_.Finish();
9530	}
9531
9532	flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9533
9534	struct ScatterNdOptionsT : public flatbuffers::NativeTable {
9535	typedef ScatterNdOptions TableType;
9536	ScatterNdOptionsT() {
9537	}
9538	};
9539
9540	struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9541	typedef ScatterNdOptionsT NativeTableType;
9542	bool Verify(flatbuffers::Verifier &verifier) const {
9543	return VerifyTableStart(verifier) &&
9544	verifier.EndTable();
9545	}
9546	ScatterNdOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9547	void UnPackTo(ScatterNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9548	static flatbuffers::Offset<ScatterNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9549	};
9550
9551	struct ScatterNdOptionsBuilder {
9552	flatbuffers::FlatBufferBuilder &fbb_;
9553	flatbuffers::uoffset_t start_;
9554	explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9555	: fbb_(_fbb) {
9556	start_ = fbb_.StartTable();
9557	}
9558	ScatterNdOptionsBuilder &operator=(const ScatterNdOptionsBuilder &);
9559	flatbuffers::Offset<ScatterNdOptions> Finish() {
9560	const auto end = fbb_.EndTable(start_);
9561	auto o = flatbuffers::Offset<ScatterNdOptions>(end);
9562	return o;
9563	}
9564	};
9565
9566	inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
9567	flatbuffers::FlatBufferBuilder &_fbb) {
9568	ScatterNdOptionsBuilder builder_(_fbb);
9569	return builder_.Finish();
9570	}
9571
9572	flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9573
9574	struct SelectV2OptionsT : public flatbuffers::NativeTable {
9575	typedef SelectV2Options TableType;
9576	SelectV2OptionsT() {
9577	}
9578	};
9579
9580	struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9581	typedef SelectV2OptionsT NativeTableType;
9582	bool Verify(flatbuffers::Verifier &verifier) const {
9583	return VerifyTableStart(verifier) &&
9584	verifier.EndTable();
9585	}
9586	SelectV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9587	void UnPackTo(SelectV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9588	static flatbuffers::Offset<SelectV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9589	};
9590
9591	struct SelectV2OptionsBuilder {
9592	flatbuffers::FlatBufferBuilder &fbb_;
9593	flatbuffers::uoffset_t start_;
9594	explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9595	: fbb_(_fbb) {
9596	start_ = fbb_.StartTable();
9597	}
9598	SelectV2OptionsBuilder &operator=(const SelectV2OptionsBuilder &);
9599	flatbuffers::Offset<SelectV2Options> Finish() {
9600	const auto end = fbb_.EndTable(start_);
9601	auto o = flatbuffers::Offset<SelectV2Options>(end);
9602	return o;
9603	}
9604	};
9605
9606	inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
9607	flatbuffers::FlatBufferBuilder &_fbb) {
9608	SelectV2OptionsBuilder builder_(_fbb);
9609	return builder_.Finish();
9610	}
9611
9612	flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9613
9614	struct DensifyOptionsT : public flatbuffers::NativeTable {
9615	typedef DensifyOptions TableType;
9616	DensifyOptionsT() {
9617	}
9618	};
9619
9620	struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9621	typedef DensifyOptionsT NativeTableType;
9622	bool Verify(flatbuffers::Verifier &verifier) const {
9623	return VerifyTableStart(verifier) &&
9624	verifier.EndTable();
9625	}
9626	DensifyOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9627	void UnPackTo(DensifyOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9628	static flatbuffers::Offset<DensifyOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9629	};
9630
9631	struct DensifyOptionsBuilder {
9632	flatbuffers::FlatBufferBuilder &fbb_;
9633	flatbuffers::uoffset_t start_;
9634	explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9635	: fbb_(_fbb) {
9636	start_ = fbb_.StartTable();
9637	}
9638	DensifyOptionsBuilder &operator=(const DensifyOptionsBuilder &);
9639	flatbuffers::Offset<DensifyOptions> Finish() {
9640	const auto end = fbb_.EndTable(start_);
9641	auto o = flatbuffers::Offset<DensifyOptions>(end);
9642	return o;
9643	}
9644	};
9645
9646	inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
9647	flatbuffers::FlatBufferBuilder &_fbb) {
9648	DensifyOptionsBuilder builder_(_fbb);
9649	return builder_.Finish();
9650	}
9651
9652	flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9653
9654	struct SegmentSumOptionsT : public flatbuffers::NativeTable {
9655	typedef SegmentSumOptions TableType;
9656	SegmentSumOptionsT() {
9657	}
9658	};
9659
9660	struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9661	typedef SegmentSumOptionsT NativeTableType;
9662	bool Verify(flatbuffers::Verifier &verifier) const {
9663	return VerifyTableStart(verifier) &&
9664	verifier.EndTable();
9665	}
9666	SegmentSumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9667	void UnPackTo(SegmentSumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9668	static flatbuffers::Offset<SegmentSumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9669	};
9670
9671	struct SegmentSumOptionsBuilder {
9672	flatbuffers::FlatBufferBuilder &fbb_;
9673	flatbuffers::uoffset_t start_;
9674	explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9675	: fbb_(_fbb) {
9676	start_ = fbb_.StartTable();
9677	}
9678	SegmentSumOptionsBuilder &operator=(const SegmentSumOptionsBuilder &);
9679	flatbuffers::Offset<SegmentSumOptions> Finish() {
9680	const auto end = fbb_.EndTable(start_);
9681	auto o = flatbuffers::Offset<SegmentSumOptions>(end);
9682	return o;
9683	}
9684	};
9685
9686	inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
9687	flatbuffers::FlatBufferBuilder &_fbb) {
9688	SegmentSumOptionsBuilder builder_(_fbb);
9689	return builder_.Finish();
9690	}
9691
9692	flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9693
9694	struct BatchMatMulOptionsT : public flatbuffers::NativeTable {
9695	typedef BatchMatMulOptions TableType;
9696	bool adj_x;
9697	bool adj_y;
9698	bool asymmetric_quantize_inputs;
9699	BatchMatMulOptionsT()
9700	: adj_x(false),
9701	adj_y(false),
9702	asymmetric_quantize_inputs(false) {
9703	}
9704	};
9705
9706	struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9707	typedef BatchMatMulOptionsT NativeTableType;
9708	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9709	VT_ADJ_X = `4`,
9710	VT_ADJ_Y = `6`,
9711	VT_ASYMMETRIC_QUANTIZE_INPUTS = `8`
9712	};
9713	bool adj_x() const {
9714	return GetField<uint8_t>(VT_ADJ_X, `0`) != `0`;
9715	}
9716	bool adj_y() const {
9717	return GetField<uint8_t>(VT_ADJ_Y, `0`) != `0`;
9718	}
9719	bool asymmetric_quantize_inputs() const {
9720	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
9721	}
9722	bool Verify(flatbuffers::Verifier &verifier) const {
9723	return VerifyTableStart(verifier) &&
9724	VerifyField<uint8_t>(verifier, VT_ADJ_X) &&
9725	VerifyField<uint8_t>(verifier, VT_ADJ_Y) &&
9726	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) &&
9727	verifier.EndTable();
9728	}
9729	BatchMatMulOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9730	void UnPackTo(BatchMatMulOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9731	static flatbuffers::Offset<BatchMatMulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9732	};
9733
9734	struct BatchMatMulOptionsBuilder {
9735	flatbuffers::FlatBufferBuilder &fbb_;
9736	flatbuffers::uoffset_t start_;
9737	void add_adj_x(bool adj_x) {
9738	fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), `0`);
9739	}
9740	void add_adj_y(bool adj_y) {
9741	fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_Y, static_cast<uint8_t>(adj_y), `0`);
9742	}
9743	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
9744	fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
9745	}
9746	explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9747	: fbb_(_fbb) {
9748	start_ = fbb_.StartTable();
9749	}
9750	BatchMatMulOptionsBuilder &operator=(const BatchMatMulOptionsBuilder &);
9751	flatbuffers::Offset<BatchMatMulOptions> Finish() {
9752	const auto end = fbb_.EndTable(start_);
9753	auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
9754	return o;
9755	}
9756	};
9757
9758	inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
9759	flatbuffers::FlatBufferBuilder &_fbb,
9760	bool adj_x = false,
9761	bool adj_y = false,
9762	bool asymmetric_quantize_inputs = false) {
9763	BatchMatMulOptionsBuilder builder_(_fbb);
9764	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
9765	builder_.add_adj_y(adj_y);
9766	builder_.add_adj_x(adj_x);
9767	return builder_.Finish();
9768	}
9769
9770	flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9771
9772	struct CumsumOptionsT : public flatbuffers::NativeTable {
9773	typedef CumsumOptions TableType;
9774	bool exclusive;
9775	bool reverse;
9776	CumsumOptionsT()
9777	: exclusive(false),
9778	reverse(false) {
9779	}
9780	};
9781
9782	struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9783	typedef CumsumOptionsT NativeTableType;
9784	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9785	VT_EXCLUSIVE = `4`,
9786	VT_REVERSE = `6`
9787	};
9788	bool exclusive() const {
9789	return GetField<uint8_t>(VT_EXCLUSIVE, `0`) != `0`;
9790	}
9791	bool reverse() const {
9792	return GetField<uint8_t>(VT_REVERSE, `0`) != `0`;
9793	}
9794	bool Verify(flatbuffers::Verifier &verifier) const {
9795	return VerifyTableStart(verifier) &&
9796	VerifyField<uint8_t>(verifier, VT_EXCLUSIVE) &&
9797	VerifyField<uint8_t>(verifier, VT_REVERSE) &&
9798	verifier.EndTable();
9799	}
9800	CumsumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9801	void UnPackTo(CumsumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9802	static flatbuffers::Offset<CumsumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9803	};
9804
9805	struct CumsumOptionsBuilder {
9806	flatbuffers::FlatBufferBuilder &fbb_;
9807	flatbuffers::uoffset_t start_;
9808	void add_exclusive(bool exclusive) {
9809	fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), `0`);
9810	}
9811	void add_reverse(bool reverse) {
9812	fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), `0`);
9813	}
9814	explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9815	: fbb_(_fbb) {
9816	start_ = fbb_.StartTable();
9817	}
9818	CumsumOptionsBuilder &operator=(const CumsumOptionsBuilder &);
9819	flatbuffers::Offset<CumsumOptions> Finish() {
9820	const auto end = fbb_.EndTable(start_);
9821	auto o = flatbuffers::Offset<CumsumOptions>(end);
9822	return o;
9823	}
9824	};
9825
9826	inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
9827	flatbuffers::FlatBufferBuilder &_fbb,
9828	bool exclusive = false,
9829	bool reverse = false) {
9830	CumsumOptionsBuilder builder_(_fbb);
9831	builder_.add_reverse(reverse);
9832	builder_.add_exclusive(exclusive);
9833	return builder_.Finish();
9834	}
9835
9836	flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9837
9838	struct BroadcastToOptionsT : public flatbuffers::NativeTable {
9839	typedef BroadcastToOptions TableType;
9840	BroadcastToOptionsT() {
9841	}
9842	};
9843
9844	struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9845	typedef BroadcastToOptionsT NativeTableType;
9846	bool Verify(flatbuffers::Verifier &verifier) const {
9847	return VerifyTableStart(verifier) &&
9848	verifier.EndTable();
9849	}
9850	BroadcastToOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9851	void UnPackTo(BroadcastToOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9852	static flatbuffers::Offset<BroadcastToOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9853	};
9854
9855	struct BroadcastToOptionsBuilder {
9856	flatbuffers::FlatBufferBuilder &fbb_;
9857	flatbuffers::uoffset_t start_;
9858	explicit BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9859	: fbb_(_fbb) {
9860	start_ = fbb_.StartTable();
9861	}
9862	BroadcastToOptionsBuilder &operator=(const BroadcastToOptionsBuilder &);
9863	flatbuffers::Offset<BroadcastToOptions> Finish() {
9864	const auto end = fbb_.EndTable(start_);
9865	auto o = flatbuffers::Offset<BroadcastToOptions>(end);
9866	return o;
9867	}
9868	};
9869
9870	inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
9871	flatbuffers::FlatBufferBuilder &_fbb) {
9872	BroadcastToOptionsBuilder builder_(_fbb);
9873	return builder_.Finish();
9874	}
9875
9876	flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9877
9878	struct Rfft2dOptionsT : public flatbuffers::NativeTable {
9879	typedef Rfft2dOptions TableType;
9880	Rfft2dOptionsT() {
9881	}
9882	};
9883
9884	struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9885	typedef Rfft2dOptionsT NativeTableType;
9886	bool Verify(flatbuffers::Verifier &verifier) const {
9887	return VerifyTableStart(verifier) &&
9888	verifier.EndTable();
9889	}
9890	Rfft2dOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9891	void UnPackTo(Rfft2dOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9892	static flatbuffers::Offset<Rfft2dOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9893	};
9894
9895	struct Rfft2dOptionsBuilder {
9896	flatbuffers::FlatBufferBuilder &fbb_;
9897	flatbuffers::uoffset_t start_;
9898	explicit Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9899	: fbb_(_fbb) {
9900	start_ = fbb_.StartTable();
9901	}
9902	Rfft2dOptionsBuilder &operator=(const Rfft2dOptionsBuilder &);
9903	flatbuffers::Offset<Rfft2dOptions> Finish() {
9904	const auto end = fbb_.EndTable(start_);
9905	auto o = flatbuffers::Offset<Rfft2dOptions>(end);
9906	return o;
9907	}
9908	};
9909
9910	inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
9911	flatbuffers::FlatBufferBuilder &_fbb) {
9912	Rfft2dOptionsBuilder builder_(_fbb);
9913	return builder_.Finish();
9914	}
9915
9916	flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9917
9918	struct HashtableOptionsT : public flatbuffers::NativeTable {
9919	typedef HashtableOptions TableType;
9920	int32_t table_id;
9921	tflite::TensorType key_dtype;
9922	tflite::TensorType value_dtype;
9923	HashtableOptionsT()
9924	: table_id(`0`),
9925	key_dtype(tflite::TensorType_FLOAT32),
9926	value_dtype(tflite::TensorType_FLOAT32) {
9927	}
9928	};
9929
9930	struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9931	typedef HashtableOptionsT NativeTableType;
9932	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9933	VT_TABLE_ID = `4`,
9934	VT_KEY_DTYPE = `6`,
9935	VT_VALUE_DTYPE = `8`
9936	};
9937	int32_t table_id() const {
9938	return GetField<int32_t>(VT_TABLE_ID, `0`);
9939	}
9940	tflite::TensorType key_dtype() const {
9941	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, `0`));
9942	}
9943	tflite::TensorType value_dtype() const {
9944	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, `0`));
9945	}
9946	bool Verify(flatbuffers::Verifier &verifier) const {
9947	return VerifyTableStart(verifier) &&
9948	VerifyField<int32_t>(verifier, VT_TABLE_ID) &&
9949	VerifyField<int8_t>(verifier, VT_KEY_DTYPE) &&
9950	VerifyField<int8_t>(verifier, VT_VALUE_DTYPE) &&
9951	verifier.EndTable();
9952	}
9953	HashtableOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9954	void UnPackTo(HashtableOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9955	static flatbuffers::Offset<HashtableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9956	};
9957
9958	struct HashtableOptionsBuilder {
9959	flatbuffers::FlatBufferBuilder &fbb_;
9960	flatbuffers::uoffset_t start_;
9961	void add_table_id(int32_t table_id) {
9962	fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, `0`);
9963	}
9964	void add_key_dtype(tflite::TensorType key_dtype) {
9965	fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), `0`);
9966	}
9967	void add_value_dtype(tflite::TensorType value_dtype) {
9968	fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), `0`);
9969	}
9970	explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9971	: fbb_(_fbb) {
9972	start_ = fbb_.StartTable();
9973	}
9974	HashtableOptionsBuilder &operator=(const HashtableOptionsBuilder &);
9975	flatbuffers::Offset<HashtableOptions> Finish() {
9976	const auto end = fbb_.EndTable(start_);
9977	auto o = flatbuffers::Offset<HashtableOptions>(end);
9978	return o;
9979	}
9980	};
9981
9982	inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(
9983	flatbuffers::FlatBufferBuilder &_fbb,
9984	int32_t table_id = `0`,
9985	tflite::TensorType key_dtype = tflite::TensorType_FLOAT32,
9986	tflite::TensorType value_dtype = tflite::TensorType_FLOAT32) {
9987	HashtableOptionsBuilder builder_(_fbb);
9988	builder_.add_table_id(table_id);
9989	builder_.add_value_dtype(value_dtype);
9990	builder_.add_key_dtype(key_dtype);
9991	return builder_.Finish();
9992	}
9993
9994	flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9995
9996	struct HashtableFindOptionsT : public flatbuffers::NativeTable {
9997	typedef HashtableFindOptions TableType;
9998	HashtableFindOptionsT() {
9999	}
10000	};
10001
10002	struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10003	typedef HashtableFindOptionsT NativeTableType;
10004	bool Verify(flatbuffers::Verifier &verifier) const {
10005	return VerifyTableStart(verifier) &&
10006	verifier.EndTable();
10007	}
10008	HashtableFindOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10009	void UnPackTo(HashtableFindOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10010	static flatbuffers::Offset<HashtableFindOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10011	};
10012
10013	struct HashtableFindOptionsBuilder {
10014	flatbuffers::FlatBufferBuilder &fbb_;
10015	flatbuffers::uoffset_t start_;
10016	explicit HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10017	: fbb_(_fbb) {
10018	start_ = fbb_.StartTable();
10019	}
10020	HashtableFindOptionsBuilder &operator=(const HashtableFindOptionsBuilder &);
10021	flatbuffers::Offset<HashtableFindOptions> Finish() {
10022	const auto end = fbb_.EndTable(start_);
10023	auto o = flatbuffers::Offset<HashtableFindOptions>(end);
10024	return o;
10025	}
10026	};
10027
10028	inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
10029	flatbuffers::FlatBufferBuilder &_fbb) {
10030	HashtableFindOptionsBuilder builder_(_fbb);
10031	return builder_.Finish();
10032	}
10033
10034	flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10035
10036	struct HashtableImportOptionsT : public flatbuffers::NativeTable {
10037	typedef HashtableImportOptions TableType;
10038	HashtableImportOptionsT() {
10039	}
10040	};
10041
10042	struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10043	typedef HashtableImportOptionsT NativeTableType;
10044	bool Verify(flatbuffers::Verifier &verifier) const {
10045	return VerifyTableStart(verifier) &&
10046	verifier.EndTable();
10047	}
10048	HashtableImportOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10049	void UnPackTo(HashtableImportOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10050	static flatbuffers::Offset<HashtableImportOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10051	};
10052
10053	struct HashtableImportOptionsBuilder {
10054	flatbuffers::FlatBufferBuilder &fbb_;
10055	flatbuffers::uoffset_t start_;
10056	explicit HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10057	: fbb_(_fbb) {
10058	start_ = fbb_.StartTable();
10059	}
10060	HashtableImportOptionsBuilder &operator=(const HashtableImportOptionsBuilder &);
10061	flatbuffers::Offset<HashtableImportOptions> Finish() {
10062	const auto end = fbb_.EndTable(start_);
10063	auto o = flatbuffers::Offset<HashtableImportOptions>(end);
10064	return o;
10065	}
10066	};
10067
10068	inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
10069	flatbuffers::FlatBufferBuilder &_fbb) {
10070	HashtableImportOptionsBuilder builder_(_fbb);
10071	return builder_.Finish();
10072	}
10073
10074	flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10075
10076	struct HashtableSizeOptionsT : public flatbuffers::NativeTable {
10077	typedef HashtableSizeOptions TableType;
10078	HashtableSizeOptionsT() {
10079	}
10080	};
10081
10082	struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10083	typedef HashtableSizeOptionsT NativeTableType;
10084	bool Verify(flatbuffers::Verifier &verifier) const {
10085	return VerifyTableStart(verifier) &&
10086	verifier.EndTable();
10087	}
10088	HashtableSizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10089	void UnPackTo(HashtableSizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10090	static flatbuffers::Offset<HashtableSizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10091	};
10092
10093	struct HashtableSizeOptionsBuilder {
10094	flatbuffers::FlatBufferBuilder &fbb_;
10095	flatbuffers::uoffset_t start_;
10096	explicit HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10097	: fbb_(_fbb) {
10098	start_ = fbb_.StartTable();
10099	}
10100	HashtableSizeOptionsBuilder &operator=(const HashtableSizeOptionsBuilder &);
10101	flatbuffers::Offset<HashtableSizeOptions> Finish() {
10102	const auto end = fbb_.EndTable(start_);
10103	auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
10104	return o;
10105	}
10106	};
10107
10108	inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
10109	flatbuffers::FlatBufferBuilder &_fbb) {
10110	HashtableSizeOptionsBuilder builder_(_fbb);
10111	return builder_.Finish();
10112	}
10113
10114	flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10115
10116	struct OperatorCodeT : public flatbuffers::NativeTable {
10117	typedef OperatorCode TableType;
10118	int8_t deprecated_builtin_code;
10119	std::string custom_code;
10120	int32_t version;
10121	tflite::BuiltinOperator builtin_code;
10122	OperatorCodeT()
10123	: deprecated_builtin_code(`0`),
10124	version(`1`),
10125	builtin_code(tflite::BuiltinOperator_ADD) {
10126	}
10127	};
10128
10129	struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10130	typedef OperatorCodeT NativeTableType;
10131	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10132	VT_DEPRECATED_BUILTIN_CODE = `4`,
10133	VT_CUSTOM_CODE = `6`,
10134	VT_VERSION = `8`,
10135	VT_BUILTIN_CODE = `10`
10136	};
10137	int8_t deprecated_builtin_code() const {
10138	return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, `0`);
10139	}
10140	const flatbuffers::String custom_code() const* {
10141	return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
10142	}
10143	int32_t version() const {
10144	return GetField<int32_t>(VT_VERSION, `1`);
10145	}
10146	tflite::BuiltinOperator builtin_code() const {
10147	return static_cast<tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, `0`));
10148	}
10149	bool Verify(flatbuffers::Verifier &verifier) const {
10150	return VerifyTableStart(verifier) &&
10151	VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE) &&
10152	VerifyOffset(verifier, VT_CUSTOM_CODE) &&
10153	verifier.VerifyString(custom_code()) &&
10154	VerifyField<int32_t>(verifier, VT_VERSION) &&
10155	VerifyField<int32_t>(verifier, VT_BUILTIN_CODE) &&
10156	verifier.EndTable();
10157	}
10158	OperatorCodeT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10159	void UnPackTo(OperatorCodeT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10160	static flatbuffers::Offset<OperatorCode> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10161	};
10162
10163	struct OperatorCodeBuilder {
10164	flatbuffers::FlatBufferBuilder &fbb_;
10165	flatbuffers::uoffset_t start_;
10166	void add_deprecated_builtin_code(int8_t deprecated_builtin_code) {
10167	fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, `0`);
10168	}
10169	void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) {
10170	fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
10171	}
10172	void add_version(int32_t version) {
10173	fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, `1`);
10174	}
10175	void add_builtin_code(tflite::BuiltinOperator builtin_code) {
10176	fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), `0`);
10177	}
10178	explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10179	: fbb_(_fbb) {
10180	start_ = fbb_.StartTable();
10181	}
10182	OperatorCodeBuilder &operator=(const OperatorCodeBuilder &);
10183	flatbuffers::Offset<OperatorCode> Finish() {
10184	const auto end = fbb_.EndTable(start_);
10185	auto o = flatbuffers::Offset<OperatorCode>(end);
10186	return o;
10187	}
10188	};
10189
10190	inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(
10191	flatbuffers::FlatBufferBuilder &_fbb,
10192	int8_t deprecated_builtin_code = `0`,
10193	flatbuffers::Offset<flatbuffers::String> custom_code = `0`,
10194	int32_t version = `1`,
10195	tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) {
10196	OperatorCodeBuilder builder_(_fbb);
10197	builder_.add_builtin_code(builtin_code);
10198	builder_.add_version(version);
10199	builder_.add_custom_code(custom_code);
10200	builder_.add_deprecated_builtin_code(deprecated_builtin_code);
10201	return builder_.Finish();
10202	}
10203
10204	inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
10205	flatbuffers::FlatBufferBuilder &_fbb,
10206	int8_t deprecated_builtin_code = `0`,
10207	const char custom_code = nullptr*,
10208	int32_t version = `1`,
10209	tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) {
10210	auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : `0`;
10211	return tflite::CreateOperatorCode(
10212	_fbb,
10213	deprecated_builtin_code,
10214	custom_code__,
10215	version,
10216	builtin_code);
10217	}
10218
10219	flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10220
10221	struct OperatorT : public flatbuffers::NativeTable {
10222	typedef Operator TableType;
10223	uint32_t opcode_index;
10224	std::vector<int32_t> inputs;
10225	std::vector<int32_t> outputs;
10226	tflite::BuiltinOptionsUnion builtin_options;
10227	std::vector<uint8_t> custom_options;
10228	tflite::CustomOptionsFormat custom_options_format;
10229	std::vector<bool> mutating_variable_inputs;
10230	std::vector<int32_t> intermediates;
10231	OperatorT()
10232	: opcode_index(`0`),
10233	custom_options_format(tflite::CustomOptionsFormat_FLEXBUFFERS) {
10234	}
10235	};
10236
10237	struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10238	typedef OperatorT NativeTableType;
10239	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10240	VT_OPCODE_INDEX = `4`,
10241	VT_INPUTS = `6`,
10242	VT_OUTPUTS = `8`,
10243	VT_BUILTIN_OPTIONS_TYPE = `10`,
10244	VT_BUILTIN_OPTIONS = `12`,
10245	VT_CUSTOM_OPTIONS = `14`,
10246	VT_CUSTOM_OPTIONS_FORMAT = `16`,
10247	VT_MUTATING_VARIABLE_INPUTS = `18`,
10248	VT_INTERMEDIATES = `20`
10249	};
10250	uint32_t opcode_index() const {
10251	return GetField<uint32_t>(VT_OPCODE_INDEX, `0`);
10252	}
10253	const flatbuffers::Vector<int32_t> inputs() const* {
10254	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
10255	}
10256	const flatbuffers::Vector<int32_t> outputs() const* {
10257	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
10258	}
10259	tflite::BuiltinOptions builtin_options_type() const {
10260	return static_cast<tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, `0`));
10261	}
10262	const void builtin_options() const* {
10263	return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
10264	}
10265	template<typename T> const T builtin_options_as() const*;
10266	const tflite::Conv2DOptions builtin_options_as_Conv2DOptions() const* {
10267	return builtin_options_type() == tflite::BuiltinOptions_Conv2DOptions ? static_cast<const tflite::Conv2DOptions >(builtin_options()) : nullptr*;
10268	}
10269	const tflite::DepthwiseConv2DOptions builtin_options_as_DepthwiseConv2DOptions() const* {
10270	return builtin_options_type() == tflite::BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const tflite::DepthwiseConv2DOptions >(builtin_options()) : nullptr*;
10271	}
10272	const tflite::ConcatEmbeddingsOptions builtin_options_as_ConcatEmbeddingsOptions() const* {
10273	return builtin_options_type() == tflite::BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const tflite::ConcatEmbeddingsOptions >(builtin_options()) : nullptr*;
10274	}
10275	const tflite::LSHProjectionOptions builtin_options_as_LSHProjectionOptions() const* {
10276	return builtin_options_type() == tflite::BuiltinOptions_LSHProjectionOptions ? static_cast<const tflite::LSHProjectionOptions >(builtin_options()) : nullptr*;
10277	}
10278	const tflite::Pool2DOptions builtin_options_as_Pool2DOptions() const* {
10279	return builtin_options_type() == tflite::BuiltinOptions_Pool2DOptions ? static_cast<const tflite::Pool2DOptions >(builtin_options()) : nullptr*;
10280	}
10281	const tflite::SVDFOptions builtin_options_as_SVDFOptions() const* {
10282	return builtin_options_type() == tflite::BuiltinOptions_SVDFOptions ? static_cast<const tflite::SVDFOptions >(builtin_options()) : nullptr*;
10283	}
10284	const tflite::RNNOptions builtin_options_as_RNNOptions() const* {
10285	return builtin_options_type() == tflite::BuiltinOptions_RNNOptions ? static_cast<const tflite::RNNOptions >(builtin_options()) : nullptr*;
10286	}
10287	const tflite::FullyConnectedOptions builtin_options_as_FullyConnectedOptions() const* {
10288	return builtin_options_type() == tflite::BuiltinOptions_FullyConnectedOptions ? static_cast<const tflite::FullyConnectedOptions >(builtin_options()) : nullptr*;
10289	}
10290	const tflite::SoftmaxOptions builtin_options_as_SoftmaxOptions() const* {
10291	return builtin_options_type() == tflite::BuiltinOptions_SoftmaxOptions ? static_cast<const tflite::SoftmaxOptions >(builtin_options()) : nullptr*;
10292	}
10293	const tflite::ConcatenationOptions builtin_options_as_ConcatenationOptions() const* {
10294	return builtin_options_type() == tflite::BuiltinOptions_ConcatenationOptions ? static_cast<const tflite::ConcatenationOptions >(builtin_options()) : nullptr*;
10295	}
10296	const tflite::AddOptions builtin_options_as_AddOptions() const* {
10297	return builtin_options_type() == tflite::BuiltinOptions_AddOptions ? static_cast<const tflite::AddOptions >(builtin_options()) : nullptr*;
10298	}
10299	const tflite::L2NormOptions builtin_options_as_L2NormOptions() const* {
10300	return builtin_options_type() == tflite::BuiltinOptions_L2NormOptions ? static_cast<const tflite::L2NormOptions >(builtin_options()) : nullptr*;
10301	}
10302	const tflite::LocalResponseNormalizationOptions builtin_options_as_LocalResponseNormalizationOptions() const* {
10303	return builtin_options_type() == tflite::BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const tflite::LocalResponseNormalizationOptions >(builtin_options()) : nullptr*;
10304	}
10305	const tflite::LSTMOptions builtin_options_as_LSTMOptions() const* {
10306	return builtin_options_type() == tflite::BuiltinOptions_LSTMOptions ? static_cast<const tflite::LSTMOptions >(builtin_options()) : nullptr*;
10307	}
10308	const tflite::ResizeBilinearOptions builtin_options_as_ResizeBilinearOptions() const* {
10309	return builtin_options_type() == tflite::BuiltinOptions_ResizeBilinearOptions ? static_cast<const tflite::ResizeBilinearOptions >(builtin_options()) : nullptr*;
10310	}
10311	const tflite::CallOptions builtin_options_as_CallOptions() const* {
10312	return builtin_options_type() == tflite::BuiltinOptions_CallOptions ? static_cast<const tflite::CallOptions >(builtin_options()) : nullptr*;
10313	}
10314	const tflite::ReshapeOptions builtin_options_as_ReshapeOptions() const* {
10315	return builtin_options_type() == tflite::BuiltinOptions_ReshapeOptions ? static_cast<const tflite::ReshapeOptions >(builtin_options()) : nullptr*;
10316	}
10317	const tflite::SkipGramOptions builtin_options_as_SkipGramOptions() const* {
10318	return builtin_options_type() == tflite::BuiltinOptions_SkipGramOptions ? static_cast<const tflite::SkipGramOptions >(builtin_options()) : nullptr*;
10319	}
10320	const tflite::SpaceToDepthOptions builtin_options_as_SpaceToDepthOptions() const* {
10321	return builtin_options_type() == tflite::BuiltinOptions_SpaceToDepthOptions ? static_cast<const tflite::SpaceToDepthOptions >(builtin_options()) : nullptr*;
10322	}
10323	const tflite::EmbeddingLookupSparseOptions builtin_options_as_EmbeddingLookupSparseOptions() const* {
10324	return builtin_options_type() == tflite::BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const tflite::EmbeddingLookupSparseOptions >(builtin_options()) : nullptr*;
10325	}
10326	const tflite::MulOptions builtin_options_as_MulOptions() const* {
10327	return builtin_options_type() == tflite::BuiltinOptions_MulOptions ? static_cast<const tflite::MulOptions >(builtin_options()) : nullptr*;
10328	}
10329	const tflite::PadOptions builtin_options_as_PadOptions() const* {
10330	return builtin_options_type() == tflite::BuiltinOptions_PadOptions ? static_cast<const tflite::PadOptions >(builtin_options()) : nullptr*;
10331	}
10332	const tflite::GatherOptions builtin_options_as_GatherOptions() const* {
10333	return builtin_options_type() == tflite::BuiltinOptions_GatherOptions ? static_cast<const tflite::GatherOptions >(builtin_options()) : nullptr*;
10334	}
10335	const tflite::BatchToSpaceNDOptions builtin_options_as_BatchToSpaceNDOptions() const* {
10336	return builtin_options_type() == tflite::BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const tflite::BatchToSpaceNDOptions >(builtin_options()) : nullptr*;
10337	}
10338	const tflite::SpaceToBatchNDOptions builtin_options_as_SpaceToBatchNDOptions() const* {
10339	return builtin_options_type() == tflite::BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const tflite::SpaceToBatchNDOptions >(builtin_options()) : nullptr*;
10340	}
10341	const tflite::TransposeOptions builtin_options_as_TransposeOptions() const* {
10342	return builtin_options_type() == tflite::BuiltinOptions_TransposeOptions ? static_cast<const tflite::TransposeOptions >(builtin_options()) : nullptr*;
10343	}
10344	const tflite::ReducerOptions builtin_options_as_ReducerOptions() const* {
10345	return builtin_options_type() == tflite::BuiltinOptions_ReducerOptions ? static_cast<const tflite::ReducerOptions >(builtin_options()) : nullptr*;
10346	}
10347	const tflite::SubOptions builtin_options_as_SubOptions() const* {
10348	return builtin_options_type() == tflite::BuiltinOptions_SubOptions ? static_cast<const tflite::SubOptions >(builtin_options()) : nullptr*;
10349	}
10350	const tflite::DivOptions builtin_options_as_DivOptions() const* {
10351	return builtin_options_type() == tflite::BuiltinOptions_DivOptions ? static_cast<const tflite::DivOptions >(builtin_options()) : nullptr*;
10352	}
10353	const tflite::SqueezeOptions builtin_options_as_SqueezeOptions() const* {
10354	return builtin_options_type() == tflite::BuiltinOptions_SqueezeOptions ? static_cast<const tflite::SqueezeOptions >(builtin_options()) : nullptr*;
10355	}
10356	const tflite::SequenceRNNOptions builtin_options_as_SequenceRNNOptions() const* {
10357	return builtin_options_type() == tflite::BuiltinOptions_SequenceRNNOptions ? static_cast<const tflite::SequenceRNNOptions >(builtin_options()) : nullptr*;
10358	}
10359	const tflite::StridedSliceOptions builtin_options_as_StridedSliceOptions() const* {
10360	return builtin_options_type() == tflite::BuiltinOptions_StridedSliceOptions ? static_cast<const tflite::StridedSliceOptions >(builtin_options()) : nullptr*;
10361	}
10362	const tflite::ExpOptions builtin_options_as_ExpOptions() const* {
10363	return builtin_options_type() == tflite::BuiltinOptions_ExpOptions ? static_cast<const tflite::ExpOptions >(builtin_options()) : nullptr*;
10364	}
10365	const tflite::TopKV2Options builtin_options_as_TopKV2Options() const* {
10366	return builtin_options_type() == tflite::BuiltinOptions_TopKV2Options ? static_cast<const tflite::TopKV2Options >(builtin_options()) : nullptr*;
10367	}
10368	const tflite::SplitOptions builtin_options_as_SplitOptions() const* {
10369	return builtin_options_type() == tflite::BuiltinOptions_SplitOptions ? static_cast<const tflite::SplitOptions >(builtin_options()) : nullptr*;
10370	}
10371	const tflite::LogSoftmaxOptions builtin_options_as_LogSoftmaxOptions() const* {
10372	return builtin_options_type() == tflite::BuiltinOptions_LogSoftmaxOptions ? static_cast<const tflite::LogSoftmaxOptions >(builtin_options()) : nullptr*;
10373	}
10374	const tflite::CastOptions builtin_options_as_CastOptions() const* {
10375	return builtin_options_type() == tflite::BuiltinOptions_CastOptions ? static_cast<const tflite::CastOptions >(builtin_options()) : nullptr*;
10376	}
10377	const tflite::DequantizeOptions builtin_options_as_DequantizeOptions() const* {
10378	return builtin_options_type() == tflite::BuiltinOptions_DequantizeOptions ? static_cast<const tflite::DequantizeOptions >(builtin_options()) : nullptr*;
10379	}
10380	const tflite::MaximumMinimumOptions builtin_options_as_MaximumMinimumOptions() const* {
10381	return builtin_options_type() == tflite::BuiltinOptions_MaximumMinimumOptions ? static_cast<const tflite::MaximumMinimumOptions >(builtin_options()) : nullptr*;
10382	}
10383	const tflite::ArgMaxOptions builtin_options_as_ArgMaxOptions() const* {
10384	return builtin_options_type() == tflite::BuiltinOptions_ArgMaxOptions ? static_cast<const tflite::ArgMaxOptions >(builtin_options()) : nullptr*;
10385	}
10386	const tflite::LessOptions builtin_options_as_LessOptions() const* {
10387	return builtin_options_type() == tflite::BuiltinOptions_LessOptions ? static_cast<const tflite::LessOptions >(builtin_options()) : nullptr*;
10388	}
10389	const tflite::NegOptions builtin_options_as_NegOptions() const* {
10390	return builtin_options_type() == tflite::BuiltinOptions_NegOptions ? static_cast<const tflite::NegOptions >(builtin_options()) : nullptr*;
10391	}
10392	const tflite::PadV2Options builtin_options_as_PadV2Options() const* {
10393	return builtin_options_type() == tflite::BuiltinOptions_PadV2Options ? static_cast<const tflite::PadV2Options >(builtin_options()) : nullptr*;
10394	}
10395	const tflite::GreaterOptions builtin_options_as_GreaterOptions() const* {
10396	return builtin_options_type() == tflite::BuiltinOptions_GreaterOptions ? static_cast<const tflite::GreaterOptions >(builtin_options()) : nullptr*;
10397	}
10398	const tflite::GreaterEqualOptions builtin_options_as_GreaterEqualOptions() const* {
10399	return builtin_options_type() == tflite::BuiltinOptions_GreaterEqualOptions ? static_cast<const tflite::GreaterEqualOptions >(builtin_options()) : nullptr*;
10400	}
10401	const tflite::LessEqualOptions builtin_options_as_LessEqualOptions() const* {
10402	return builtin_options_type() == tflite::BuiltinOptions_LessEqualOptions ? static_cast<const tflite::LessEqualOptions >(builtin_options()) : nullptr*;
10403	}
10404	const tflite::SelectOptions builtin_options_as_SelectOptions() const* {
10405	return builtin_options_type() == tflite::BuiltinOptions_SelectOptions ? static_cast<const tflite::SelectOptions >(builtin_options()) : nullptr*;
10406	}
10407	const tflite::SliceOptions builtin_options_as_SliceOptions() const* {
10408	return builtin_options_type() == tflite::BuiltinOptions_SliceOptions ? static_cast<const tflite::SliceOptions >(builtin_options()) : nullptr*;
10409	}
10410	const tflite::TransposeConvOptions builtin_options_as_TransposeConvOptions() const* {
10411	return builtin_options_type() == tflite::BuiltinOptions_TransposeConvOptions ? static_cast<const tflite::TransposeConvOptions >(builtin_options()) : nullptr*;
10412	}
10413	const tflite::SparseToDenseOptions builtin_options_as_SparseToDenseOptions() const* {
10414	return builtin_options_type() == tflite::BuiltinOptions_SparseToDenseOptions ? static_cast<const tflite::SparseToDenseOptions >(builtin_options()) : nullptr*;
10415	}
10416	const tflite::TileOptions builtin_options_as_TileOptions() const* {
10417	return builtin_options_type() == tflite::BuiltinOptions_TileOptions ? static_cast<const tflite::TileOptions >(builtin_options()) : nullptr*;
10418	}
10419	const tflite::ExpandDimsOptions builtin_options_as_ExpandDimsOptions() const* {
10420	return builtin_options_type() == tflite::BuiltinOptions_ExpandDimsOptions ? static_cast<const tflite::ExpandDimsOptions >(builtin_options()) : nullptr*;
10421	}
10422	const tflite::EqualOptions builtin_options_as_EqualOptions() const* {
10423	return builtin_options_type() == tflite::BuiltinOptions_EqualOptions ? static_cast<const tflite::EqualOptions >(builtin_options()) : nullptr*;
10424	}
10425	const tflite::NotEqualOptions builtin_options_as_NotEqualOptions() const* {
10426	return builtin_options_type() == tflite::BuiltinOptions_NotEqualOptions ? static_cast<const tflite::NotEqualOptions >(builtin_options()) : nullptr*;
10427	}
10428	const tflite::ShapeOptions builtin_options_as_ShapeOptions() const* {
10429	return builtin_options_type() == tflite::BuiltinOptions_ShapeOptions ? static_cast<const tflite::ShapeOptions >(builtin_options()) : nullptr*;
10430	}
10431	const tflite::PowOptions builtin_options_as_PowOptions() const* {
10432	return builtin_options_type() == tflite::BuiltinOptions_PowOptions ? static_cast<const tflite::PowOptions >(builtin_options()) : nullptr*;
10433	}
10434	const tflite::ArgMinOptions builtin_options_as_ArgMinOptions() const* {
10435	return builtin_options_type() == tflite::BuiltinOptions_ArgMinOptions ? static_cast<const tflite::ArgMinOptions >(builtin_options()) : nullptr*;
10436	}
10437	const tflite::FakeQuantOptions builtin_options_as_FakeQuantOptions() const* {
10438	return builtin_options_type() == tflite::BuiltinOptions_FakeQuantOptions ? static_cast<const tflite::FakeQuantOptions >(builtin_options()) : nullptr*;
10439	}
10440	const tflite::PackOptions builtin_options_as_PackOptions() const* {
10441	return builtin_options_type() == tflite::BuiltinOptions_PackOptions ? static_cast<const tflite::PackOptions >(builtin_options()) : nullptr*;
10442	}
10443	const tflite::LogicalOrOptions builtin_options_as_LogicalOrOptions() const* {
10444	return builtin_options_type() == tflite::BuiltinOptions_LogicalOrOptions ? static_cast<const tflite::LogicalOrOptions >(builtin_options()) : nullptr*;
10445	}
10446	const tflite::OneHotOptions builtin_options_as_OneHotOptions() const* {
10447	return builtin_options_type() == tflite::BuiltinOptions_OneHotOptions ? static_cast<const tflite::OneHotOptions >(builtin_options()) : nullptr*;
10448	}
10449	const tflite::LogicalAndOptions builtin_options_as_LogicalAndOptions() const* {
10450	return builtin_options_type() == tflite::BuiltinOptions_LogicalAndOptions ? static_cast<const tflite::LogicalAndOptions >(builtin_options()) : nullptr*;
10451	}
10452	const tflite::LogicalNotOptions builtin_options_as_LogicalNotOptions() const* {
10453	return builtin_options_type() == tflite::BuiltinOptions_LogicalNotOptions ? static_cast<const tflite::LogicalNotOptions >(builtin_options()) : nullptr*;
10454	}
10455	const tflite::UnpackOptions builtin_options_as_UnpackOptions() const* {
10456	return builtin_options_type() == tflite::BuiltinOptions_UnpackOptions ? static_cast<const tflite::UnpackOptions >(builtin_options()) : nullptr*;
10457	}
10458	const tflite::FloorDivOptions builtin_options_as_FloorDivOptions() const* {
10459	return builtin_options_type() == tflite::BuiltinOptions_FloorDivOptions ? static_cast<const tflite::FloorDivOptions >(builtin_options()) : nullptr*;
10460	}
10461	const tflite::SquareOptions builtin_options_as_SquareOptions() const* {
10462	return builtin_options_type() == tflite::BuiltinOptions_SquareOptions ? static_cast<const tflite::SquareOptions >(builtin_options()) : nullptr*;
10463	}
10464	const tflite::ZerosLikeOptions builtin_options_as_ZerosLikeOptions() const* {
10465	return builtin_options_type() == tflite::BuiltinOptions_ZerosLikeOptions ? static_cast<const tflite::ZerosLikeOptions >(builtin_options()) : nullptr*;
10466	}
10467	const tflite::FillOptions builtin_options_as_FillOptions() const* {
10468	return builtin_options_type() == tflite::BuiltinOptions_FillOptions ? static_cast<const tflite::FillOptions >(builtin_options()) : nullptr*;
10469	}
10470	const tflite::BidirectionalSequenceLSTMOptions builtin_options_as_BidirectionalSequenceLSTMOptions() const* {
10471	return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceLSTMOptions ? static_cast<const tflite::BidirectionalSequenceLSTMOptions >(builtin_options()) : nullptr*;
10472	}
10473	const tflite::BidirectionalSequenceRNNOptions builtin_options_as_BidirectionalSequenceRNNOptions() const* {
10474	return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceRNNOptions ? static_cast<const tflite::BidirectionalSequenceRNNOptions >(builtin_options()) : nullptr*;
10475	}
10476	const tflite::UnidirectionalSequenceLSTMOptions builtin_options_as_UnidirectionalSequenceLSTMOptions() const* {
10477	return builtin_options_type() == tflite::BuiltinOptions_UnidirectionalSequenceLSTMOptions ? static_cast<const tflite::UnidirectionalSequenceLSTMOptions >(builtin_options()) : nullptr*;
10478	}
10479	const tflite::FloorModOptions builtin_options_as_FloorModOptions() const* {
10480	return builtin_options_type() == tflite::BuiltinOptions_FloorModOptions ? static_cast<const tflite::FloorModOptions >(builtin_options()) : nullptr*;
10481	}
10482	const tflite::RangeOptions builtin_options_as_RangeOptions() const* {
10483	return builtin_options_type() == tflite::BuiltinOptions_RangeOptions ? static_cast<const tflite::RangeOptions >(builtin_options()) : nullptr*;
10484	}
10485	const tflite::ResizeNearestNeighborOptions builtin_options_as_ResizeNearestNeighborOptions() const* {
10486	return builtin_options_type() == tflite::BuiltinOptions_ResizeNearestNeighborOptions ? static_cast<const tflite::ResizeNearestNeighborOptions >(builtin_options()) : nullptr*;
10487	}
10488	const tflite::LeakyReluOptions builtin_options_as_LeakyReluOptions() const* {
10489	return builtin_options_type() == tflite::BuiltinOptions_LeakyReluOptions ? static_cast<const tflite::LeakyReluOptions >(builtin_options()) : nullptr*;
10490	}
10491	const tflite::SquaredDifferenceOptions builtin_options_as_SquaredDifferenceOptions() const* {
10492	return builtin_options_type() == tflite::BuiltinOptions_SquaredDifferenceOptions ? static_cast<const tflite::SquaredDifferenceOptions >(builtin_options()) : nullptr*;
10493	}
10494	const tflite::MirrorPadOptions builtin_options_as_MirrorPadOptions() const* {
10495	return builtin_options_type() == tflite::BuiltinOptions_MirrorPadOptions ? static_cast<const tflite::MirrorPadOptions >(builtin_options()) : nullptr*;
10496	}
10497	const tflite::AbsOptions builtin_options_as_AbsOptions() const* {
10498	return builtin_options_type() == tflite::BuiltinOptions_AbsOptions ? static_cast<const tflite::AbsOptions >(builtin_options()) : nullptr*;
10499	}
10500	const tflite::SplitVOptions builtin_options_as_SplitVOptions() const* {
10501	return builtin_options_type() == tflite::BuiltinOptions_SplitVOptions ? static_cast<const tflite::SplitVOptions >(builtin_options()) : nullptr*;
10502	}
10503	const tflite::UniqueOptions builtin_options_as_UniqueOptions() const* {
10504	return builtin_options_type() == tflite::BuiltinOptions_UniqueOptions ? static_cast<const tflite::UniqueOptions >(builtin_options()) : nullptr*;
10505	}
10506	const tflite::ReverseV2Options builtin_options_as_ReverseV2Options() const* {
10507	return builtin_options_type() == tflite::BuiltinOptions_ReverseV2Options ? static_cast<const tflite::ReverseV2Options >(builtin_options()) : nullptr*;
10508	}
10509	const tflite::AddNOptions builtin_options_as_AddNOptions() const* {
10510	return builtin_options_type() == tflite::BuiltinOptions_AddNOptions ? static_cast<const tflite::AddNOptions >(builtin_options()) : nullptr*;
10511	}
10512	const tflite::GatherNdOptions builtin_options_as_GatherNdOptions() const* {
10513	return builtin_options_type() == tflite::BuiltinOptions_GatherNdOptions ? static_cast<const tflite::GatherNdOptions >(builtin_options()) : nullptr*;
10514	}
10515	const tflite::CosOptions builtin_options_as_CosOptions() const* {
10516	return builtin_options_type() == tflite::BuiltinOptions_CosOptions ? static_cast<const tflite::CosOptions >(builtin_options()) : nullptr*;
10517	}
10518	const tflite::WhereOptions builtin_options_as_WhereOptions() const* {
10519	return builtin_options_type() == tflite::BuiltinOptions_WhereOptions ? static_cast<const tflite::WhereOptions >(builtin_options()) : nullptr*;
10520	}
10521	const tflite::RankOptions builtin_options_as_RankOptions() const* {
10522	return builtin_options_type() == tflite::BuiltinOptions_RankOptions ? static_cast<const tflite::RankOptions >(builtin_options()) : nullptr*;
10523	}
10524	const tflite::ReverseSequenceOptions builtin_options_as_ReverseSequenceOptions() const* {
10525	return builtin_options_type() == tflite::BuiltinOptions_ReverseSequenceOptions ? static_cast<const tflite::ReverseSequenceOptions >(builtin_options()) : nullptr*;
10526	}
10527	const tflite::MatrixDiagOptions builtin_options_as_MatrixDiagOptions() const* {
10528	return builtin_options_type() == tflite::BuiltinOptions_MatrixDiagOptions ? static_cast<const tflite::MatrixDiagOptions >(builtin_options()) : nullptr*;
10529	}
10530	const tflite::QuantizeOptions builtin_options_as_QuantizeOptions() const* {
10531	return builtin_options_type() == tflite::BuiltinOptions_QuantizeOptions ? static_cast<const tflite::QuantizeOptions >(builtin_options()) : nullptr*;
10532	}
10533	const tflite::MatrixSetDiagOptions builtin_options_as_MatrixSetDiagOptions() const* {
10534	return builtin_options_type() == tflite::BuiltinOptions_MatrixSetDiagOptions ? static_cast<const tflite::MatrixSetDiagOptions >(builtin_options()) : nullptr*;
10535	}
10536	const tflite::HardSwishOptions builtin_options_as_HardSwishOptions() const* {
10537	return builtin_options_type() == tflite::BuiltinOptions_HardSwishOptions ? static_cast<const tflite::HardSwishOptions >(builtin_options()) : nullptr*;
10538	}
10539	const tflite::IfOptions builtin_options_as_IfOptions() const* {
10540	return builtin_options_type() == tflite::BuiltinOptions_IfOptions ? static_cast<const tflite::IfOptions >(builtin_options()) : nullptr*;
10541	}
10542	const tflite::WhileOptions builtin_options_as_WhileOptions() const* {
10543	return builtin_options_type() == tflite::BuiltinOptions_WhileOptions ? static_cast<const tflite::WhileOptions >(builtin_options()) : nullptr*;
10544	}
10545	const tflite::DepthToSpaceOptions builtin_options_as_DepthToSpaceOptions() const* {
10546	return builtin_options_type() == tflite::BuiltinOptions_DepthToSpaceOptions ? static_cast<const tflite::DepthToSpaceOptions >(builtin_options()) : nullptr*;
10547	}
10548	const tflite::NonMaxSuppressionV4Options builtin_options_as_NonMaxSuppressionV4Options() const* {
10549	return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV4Options ? static_cast<const tflite::NonMaxSuppressionV4Options >(builtin_options()) : nullptr*;
10550	}
10551	const tflite::NonMaxSuppressionV5Options builtin_options_as_NonMaxSuppressionV5Options() const* {
10552	return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV5Options ? static_cast<const tflite::NonMaxSuppressionV5Options >(builtin_options()) : nullptr*;
10553	}
10554	const tflite::ScatterNdOptions builtin_options_as_ScatterNdOptions() const* {
10555	return builtin_options_type() == tflite::BuiltinOptions_ScatterNdOptions ? static_cast<const tflite::ScatterNdOptions >(builtin_options()) : nullptr*;
10556	}
10557	const tflite::SelectV2Options builtin_options_as_SelectV2Options() const* {
10558	return builtin_options_type() == tflite::BuiltinOptions_SelectV2Options ? static_cast<const tflite::SelectV2Options >(builtin_options()) : nullptr*;
10559	}
10560	const tflite::DensifyOptions builtin_options_as_DensifyOptions() const* {
10561	return builtin_options_type() == tflite::BuiltinOptions_DensifyOptions ? static_cast<const tflite::DensifyOptions >(builtin_options()) : nullptr*;
10562	}
10563	const tflite::SegmentSumOptions builtin_options_as_SegmentSumOptions() const* {
10564	return builtin_options_type() == tflite::BuiltinOptions_SegmentSumOptions ? static_cast<const tflite::SegmentSumOptions >(builtin_options()) : nullptr*;
10565	}
10566	const tflite::BatchMatMulOptions builtin_options_as_BatchMatMulOptions() const* {
10567	return builtin_options_type() == tflite::BuiltinOptions_BatchMatMulOptions ? static_cast<const tflite::BatchMatMulOptions >(builtin_options()) : nullptr*;
10568	}
10569	const tflite::CumsumOptions builtin_options_as_CumsumOptions() const* {
10570	return builtin_options_type() == tflite::BuiltinOptions_CumsumOptions ? static_cast<const tflite::CumsumOptions >(builtin_options()) : nullptr*;
10571	}
10572	const tflite::CallOnceOptions builtin_options_as_CallOnceOptions() const* {
10573	return builtin_options_type() == tflite::BuiltinOptions_CallOnceOptions ? static_cast<const tflite::CallOnceOptions >(builtin_options()) : nullptr*;
10574	}
10575	const tflite::BroadcastToOptions builtin_options_as_BroadcastToOptions() const* {
10576	return builtin_options_type() == tflite::BuiltinOptions_BroadcastToOptions ? static_cast<const tflite::BroadcastToOptions >(builtin_options()) : nullptr*;
10577	}
10578	const tflite::Rfft2dOptions builtin_options_as_Rfft2dOptions() const* {
10579	return builtin_options_type() == tflite::BuiltinOptions_Rfft2dOptions ? static_cast<const tflite::Rfft2dOptions >(builtin_options()) : nullptr*;
10580	}
10581	const tflite::Conv3DOptions builtin_options_as_Conv3DOptions() const* {
10582	return builtin_options_type() == tflite::BuiltinOptions_Conv3DOptions ? static_cast<const tflite::Conv3DOptions >(builtin_options()) : nullptr*;
10583	}
10584	const tflite::HashtableOptions builtin_options_as_HashtableOptions() const* {
10585	return builtin_options_type() == tflite::BuiltinOptions_HashtableOptions ? static_cast<const tflite::HashtableOptions >(builtin_options()) : nullptr*;
10586	}
10587	const tflite::HashtableFindOptions builtin_options_as_HashtableFindOptions() const* {
10588	return builtin_options_type() == tflite::BuiltinOptions_HashtableFindOptions ? static_cast<const tflite::HashtableFindOptions >(builtin_options()) : nullptr*;
10589	}
10590	const tflite::HashtableImportOptions builtin_options_as_HashtableImportOptions() const* {
10591	return builtin_options_type() == tflite::BuiltinOptions_HashtableImportOptions ? static_cast<const tflite::HashtableImportOptions >(builtin_options()) : nullptr*;
10592	}
10593	const tflite::HashtableSizeOptions builtin_options_as_HashtableSizeOptions() const* {
10594	return builtin_options_type() == tflite::BuiltinOptions_HashtableSizeOptions ? static_cast<const tflite::HashtableSizeOptions >(builtin_options()) : nullptr*;
10595	}
10596	const flatbuffers::Vector<uint8_t> custom_options() const* {
10597	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
10598	}
10599	tflite::CustomOptionsFormat custom_options_format() const {
10600	return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, `0`));
10601	}
10602	const flatbuffers::Vector<uint8_t> mutating_variable_inputs() const* {
10603	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
10604	}
10605	const flatbuffers::Vector<int32_t> intermediates() const* {
10606	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
10607	}
10608	bool Verify(flatbuffers::Verifier &verifier) const {
10609	return VerifyTableStart(verifier) &&
10610	VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
10611	VerifyOffset(verifier, VT_INPUTS) &&
10612	verifier.VerifyVector(inputs()) &&
10613	VerifyOffset(verifier, VT_OUTPUTS) &&
10614	verifier.VerifyVector(outputs()) &&
10615	VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
10616	VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
10617	VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
10618	VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
10619	verifier.VerifyVector(custom_options()) &&
10620	VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
10621	VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
10622	verifier.VerifyVector(mutating_variable_inputs()) &&
10623	VerifyOffset(verifier, VT_INTERMEDIATES) &&
10624	verifier.VerifyVector(intermediates()) &&
10625	verifier.EndTable();
10626	}
10627	OperatorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10628	void UnPackTo(OperatorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10629	static flatbuffers::Offset<Operator> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10630	};
10631
10632	template<> inline const tflite::Conv2DOptions Operator::builtin_options_as<tflite::Conv2DOptions>() const* {
10633	return builtin_options_as_Conv2DOptions();
10634	}
10635
10636	template<> inline const tflite::DepthwiseConv2DOptions Operator::builtin_options_as<tflite::DepthwiseConv2DOptions>() const* {
10637	return builtin_options_as_DepthwiseConv2DOptions();
10638	}
10639
10640	template<> inline const tflite::ConcatEmbeddingsOptions Operator::builtin_options_as<tflite::ConcatEmbeddingsOptions>() const* {
10641	return builtin_options_as_ConcatEmbeddingsOptions();
10642	}
10643
10644	template<> inline const tflite::LSHProjectionOptions Operator::builtin_options_as<tflite::LSHProjectionOptions>() const* {
10645	return builtin_options_as_LSHProjectionOptions();
10646	}
10647
10648	template<> inline const tflite::Pool2DOptions Operator::builtin_options_as<tflite::Pool2DOptions>() const* {
10649	return builtin_options_as_Pool2DOptions();
10650	}
10651
10652	template<> inline const tflite::SVDFOptions Operator::builtin_options_as<tflite::SVDFOptions>() const* {
10653	return builtin_options_as_SVDFOptions();
10654	}
10655
10656	template<> inline const tflite::RNNOptions Operator::builtin_options_as<tflite::RNNOptions>() const* {
10657	return builtin_options_as_RNNOptions();
10658	}
10659
10660	template<> inline const tflite::FullyConnectedOptions Operator::builtin_options_as<tflite::FullyConnectedOptions>() const* {
10661	return builtin_options_as_FullyConnectedOptions();
10662	}
10663
10664	template<> inline const tflite::SoftmaxOptions Operator::builtin_options_as<tflite::SoftmaxOptions>() const* {
10665	return builtin_options_as_SoftmaxOptions();
10666	}
10667
10668	template<> inline const tflite::ConcatenationOptions Operator::builtin_options_as<tflite::ConcatenationOptions>() const* {
10669	return builtin_options_as_ConcatenationOptions();
10670	}
10671
10672	template<> inline const tflite::AddOptions Operator::builtin_options_as<tflite::AddOptions>() const* {
10673	return builtin_options_as_AddOptions();
10674	}
10675
10676	template<> inline const tflite::L2NormOptions Operator::builtin_options_as<tflite::L2NormOptions>() const* {
10677	return builtin_options_as_L2NormOptions();
10678	}
10679
10680	template<> inline const tflite::LocalResponseNormalizationOptions Operator::builtin_options_as<tflite::LocalResponseNormalizationOptions>() const* {
10681	return builtin_options_as_LocalResponseNormalizationOptions();
10682	}
10683
10684	template<> inline const tflite::LSTMOptions Operator::builtin_options_as<tflite::LSTMOptions>() const* {
10685	return builtin_options_as_LSTMOptions();
10686	}
10687
10688	template<> inline const tflite::ResizeBilinearOptions Operator::builtin_options_as<tflite::ResizeBilinearOptions>() const* {
10689	return builtin_options_as_ResizeBilinearOptions();
10690	}
10691
10692	template<> inline const tflite::CallOptions Operator::builtin_options_as<tflite::CallOptions>() const* {
10693	return builtin_options_as_CallOptions();
10694	}
10695
10696	template<> inline const tflite::ReshapeOptions Operator::builtin_options_as<tflite::ReshapeOptions>() const* {
10697	return builtin_options_as_ReshapeOptions();
10698	}
10699
10700	template<> inline const tflite::SkipGramOptions Operator::builtin_options_as<tflite::SkipGramOptions>() const* {
10701	return builtin_options_as_SkipGramOptions();
10702	}
10703
10704	template<> inline const tflite::SpaceToDepthOptions Operator::builtin_options_as<tflite::SpaceToDepthOptions>() const* {
10705	return builtin_options_as_SpaceToDepthOptions();
10706	}
10707
10708	template<> inline const tflite::EmbeddingLookupSparseOptions Operator::builtin_options_as<tflite::EmbeddingLookupSparseOptions>() const* {
10709	return builtin_options_as_EmbeddingLookupSparseOptions();
10710	}
10711
10712	template<> inline const tflite::MulOptions Operator::builtin_options_as<tflite::MulOptions>() const* {
10713	return builtin_options_as_MulOptions();
10714	}
10715
10716	template<> inline const tflite::PadOptions Operator::builtin_options_as<tflite::PadOptions>() const* {
10717	return builtin_options_as_PadOptions();
10718	}
10719
10720	template<> inline const tflite::GatherOptions Operator::builtin_options_as<tflite::GatherOptions>() const* {
10721	return builtin_options_as_GatherOptions();
10722	}
10723
10724	template<> inline const tflite::BatchToSpaceNDOptions Operator::builtin_options_as<tflite::BatchToSpaceNDOptions>() const* {
10725	return builtin_options_as_BatchToSpaceNDOptions();
10726	}
10727
10728	template<> inline const tflite::SpaceToBatchNDOptions Operator::builtin_options_as<tflite::SpaceToBatchNDOptions>() const* {
10729	return builtin_options_as_SpaceToBatchNDOptions();
10730	}
10731
10732	template<> inline const tflite::TransposeOptions Operator::builtin_options_as<tflite::TransposeOptions>() const* {
10733	return builtin_options_as_TransposeOptions();
10734	}
10735
10736	template<> inline const tflite::ReducerOptions Operator::builtin_options_as<tflite::ReducerOptions>() const* {
10737	return builtin_options_as_ReducerOptions();
10738	}
10739
10740	template<> inline const tflite::SubOptions Operator::builtin_options_as<tflite::SubOptions>() const* {
10741	return builtin_options_as_SubOptions();
10742	}
10743
10744	template<> inline const tflite::DivOptions Operator::builtin_options_as<tflite::DivOptions>() const* {
10745	return builtin_options_as_DivOptions();
10746	}
10747
10748	template<> inline const tflite::SqueezeOptions Operator::builtin_options_as<tflite::SqueezeOptions>() const* {
10749	return builtin_options_as_SqueezeOptions();
10750	}
10751
10752	template<> inline const tflite::SequenceRNNOptions Operator::builtin_options_as<tflite::SequenceRNNOptions>() const* {
10753	return builtin_options_as_SequenceRNNOptions();
10754	}
10755
10756	template<> inline const tflite::StridedSliceOptions Operator::builtin_options_as<tflite::StridedSliceOptions>() const* {
10757	return builtin_options_as_StridedSliceOptions();
10758	}
10759
10760	template<> inline const tflite::ExpOptions Operator::builtin_options_as<tflite::ExpOptions>() const* {
10761	return builtin_options_as_ExpOptions();
10762	}
10763
10764	template<> inline const tflite::TopKV2Options Operator::builtin_options_as<tflite::TopKV2Options>() const* {
10765	return builtin_options_as_TopKV2Options();
10766	}
10767
10768	template<> inline const tflite::SplitOptions Operator::builtin_options_as<tflite::SplitOptions>() const* {
10769	return builtin_options_as_SplitOptions();
10770	}
10771
10772	template<> inline const tflite::LogSoftmaxOptions Operator::builtin_options_as<tflite::LogSoftmaxOptions>() const* {
10773	return builtin_options_as_LogSoftmaxOptions();
10774	}
10775
10776	template<> inline const tflite::CastOptions Operator::builtin_options_as<tflite::CastOptions>() const* {
10777	return builtin_options_as_CastOptions();
10778	}
10779
10780	template<> inline const tflite::DequantizeOptions Operator::builtin_options_as<tflite::DequantizeOptions>() const* {
10781	return builtin_options_as_DequantizeOptions();
10782	}
10783
10784	template<> inline const tflite::MaximumMinimumOptions Operator::builtin_options_as<tflite::MaximumMinimumOptions>() const* {
10785	return builtin_options_as_MaximumMinimumOptions();
10786	}
10787
10788	template<> inline const tflite::ArgMaxOptions Operator::builtin_options_as<tflite::ArgMaxOptions>() const* {
10789	return builtin_options_as_ArgMaxOptions();
10790	}
10791
10792	template<> inline const tflite::LessOptions Operator::builtin_options_as<tflite::LessOptions>() const* {
10793	return builtin_options_as_LessOptions();
10794	}
10795
10796	template<> inline const tflite::NegOptions Operator::builtin_options_as<tflite::NegOptions>() const* {
10797	return builtin_options_as_NegOptions();
10798	}
10799
10800	template<> inline const tflite::PadV2Options Operator::builtin_options_as<tflite::PadV2Options>() const* {
10801	return builtin_options_as_PadV2Options();
10802	}
10803
10804	template<> inline const tflite::GreaterOptions Operator::builtin_options_as<tflite::GreaterOptions>() const* {
10805	return builtin_options_as_GreaterOptions();
10806	}
10807
10808	template<> inline const tflite::GreaterEqualOptions Operator::builtin_options_as<tflite::GreaterEqualOptions>() const* {
10809	return builtin_options_as_GreaterEqualOptions();
10810	}
10811
10812	template<> inline const tflite::LessEqualOptions Operator::builtin_options_as<tflite::LessEqualOptions>() const* {
10813	return builtin_options_as_LessEqualOptions();
10814	}
10815
10816	template<> inline const tflite::SelectOptions Operator::builtin_options_as<tflite::SelectOptions>() const* {
10817	return builtin_options_as_SelectOptions();
10818	}
10819
10820	template<> inline const tflite::SliceOptions Operator::builtin_options_as<tflite::SliceOptions>() const* {
10821	return builtin_options_as_SliceOptions();
10822	}
10823
10824	template<> inline const tflite::TransposeConvOptions Operator::builtin_options_as<tflite::TransposeConvOptions>() const* {
10825	return builtin_options_as_TransposeConvOptions();
10826	}
10827
10828	template<> inline const tflite::SparseToDenseOptions Operator::builtin_options_as<tflite::SparseToDenseOptions>() const* {
10829	return builtin_options_as_SparseToDenseOptions();
10830	}
10831
10832	template<> inline const tflite::TileOptions Operator::builtin_options_as<tflite::TileOptions>() const* {
10833	return builtin_options_as_TileOptions();
10834	}
10835
10836	template<> inline const tflite::ExpandDimsOptions Operator::builtin_options_as<tflite::ExpandDimsOptions>() const* {
10837	return builtin_options_as_ExpandDimsOptions();
10838	}
10839
10840	template<> inline const tflite::EqualOptions Operator::builtin_options_as<tflite::EqualOptions>() const* {
10841	return builtin_options_as_EqualOptions();
10842	}
10843
10844	template<> inline const tflite::NotEqualOptions Operator::builtin_options_as<tflite::NotEqualOptions>() const* {
10845	return builtin_options_as_NotEqualOptions();
10846	}
10847
10848	template<> inline const tflite::ShapeOptions Operator::builtin_options_as<tflite::ShapeOptions>() const* {
10849	return builtin_options_as_ShapeOptions();
10850	}
10851
10852	template<> inline const tflite::PowOptions Operator::builtin_options_as<tflite::PowOptions>() const* {
10853	return builtin_options_as_PowOptions();
10854	}
10855
10856	template<> inline const tflite::ArgMinOptions Operator::builtin_options_as<tflite::ArgMinOptions>() const* {
10857	return builtin_options_as_ArgMinOptions();
10858	}
10859
10860	template<> inline const tflite::FakeQuantOptions Operator::builtin_options_as<tflite::FakeQuantOptions>() const* {
10861	return builtin_options_as_FakeQuantOptions();
10862	}
10863
10864	template<> inline const tflite::PackOptions Operator::builtin_options_as<tflite::PackOptions>() const* {
10865	return builtin_options_as_PackOptions();
10866	}
10867
10868	template<> inline const tflite::LogicalOrOptions Operator::builtin_options_as<tflite::LogicalOrOptions>() const* {
10869	return builtin_options_as_LogicalOrOptions();
10870	}
10871
10872	template<> inline const tflite::OneHotOptions Operator::builtin_options_as<tflite::OneHotOptions>() const* {
10873	return builtin_options_as_OneHotOptions();
10874	}
10875
10876	template<> inline const tflite::LogicalAndOptions Operator::builtin_options_as<tflite::LogicalAndOptions>() const* {
10877	return builtin_options_as_LogicalAndOptions();
10878	}
10879
10880	template<> inline const tflite::LogicalNotOptions Operator::builtin_options_as<tflite::LogicalNotOptions>() const* {
10881	return builtin_options_as_LogicalNotOptions();
10882	}
10883
10884	template<> inline const tflite::UnpackOptions Operator::builtin_options_as<tflite::UnpackOptions>() const* {
10885	return builtin_options_as_UnpackOptions();
10886	}
10887
10888	template<> inline const tflite::FloorDivOptions Operator::builtin_options_as<tflite::FloorDivOptions>() const* {
10889	return builtin_options_as_FloorDivOptions();
10890	}
10891
10892	template<> inline const tflite::SquareOptions Operator::builtin_options_as<tflite::SquareOptions>() const* {
10893	return builtin_options_as_SquareOptions();
10894	}
10895
10896	template<> inline const tflite::ZerosLikeOptions Operator::builtin_options_as<tflite::ZerosLikeOptions>() const* {
10897	return builtin_options_as_ZerosLikeOptions();
10898	}
10899
10900	template<> inline const tflite::FillOptions Operator::builtin_options_as<tflite::FillOptions>() const* {
10901	return builtin_options_as_FillOptions();
10902	}
10903
10904	template<> inline const tflite::BidirectionalSequenceLSTMOptions Operator::builtin_options_as<tflite::BidirectionalSequenceLSTMOptions>() const* {
10905	return builtin_options_as_BidirectionalSequenceLSTMOptions();
10906	}
10907
10908	template<> inline const tflite::BidirectionalSequenceRNNOptions Operator::builtin_options_as<tflite::BidirectionalSequenceRNNOptions>() const* {
10909	return builtin_options_as_BidirectionalSequenceRNNOptions();
10910	}
10911
10912	template<> inline const tflite::UnidirectionalSequenceLSTMOptions Operator::builtin_options_as<tflite::UnidirectionalSequenceLSTMOptions>() const* {
10913	return builtin_options_as_UnidirectionalSequenceLSTMOptions();
10914	}
10915
10916	template<> inline const tflite::FloorModOptions Operator::builtin_options_as<tflite::FloorModOptions>() const* {
10917	return builtin_options_as_FloorModOptions();
10918	}
10919
10920	template<> inline const tflite::RangeOptions Operator::builtin_options_as<tflite::RangeOptions>() const* {
10921	return builtin_options_as_RangeOptions();
10922	}
10923
10924	template<> inline const tflite::ResizeNearestNeighborOptions Operator::builtin_options_as<tflite::ResizeNearestNeighborOptions>() const* {
10925	return builtin_options_as_ResizeNearestNeighborOptions();
10926	}
10927
10928	template<> inline const tflite::LeakyReluOptions Operator::builtin_options_as<tflite::LeakyReluOptions>() const* {
10929	return builtin_options_as_LeakyReluOptions();
10930	}
10931
10932	template<> inline const tflite::SquaredDifferenceOptions Operator::builtin_options_as<tflite::SquaredDifferenceOptions>() const* {
10933	return builtin_options_as_SquaredDifferenceOptions();
10934	}
10935
10936	template<> inline const tflite::MirrorPadOptions Operator::builtin_options_as<tflite::MirrorPadOptions>() const* {
10937	return builtin_options_as_MirrorPadOptions();
10938	}
10939
10940	template<> inline const tflite::AbsOptions Operator::builtin_options_as<tflite::AbsOptions>() const* {
10941	return builtin_options_as_AbsOptions();
10942	}
10943
10944	template<> inline const tflite::SplitVOptions Operator::builtin_options_as<tflite::SplitVOptions>() const* {
10945	return builtin_options_as_SplitVOptions();
10946	}
10947
10948	template<> inline const tflite::UniqueOptions Operator::builtin_options_as<tflite::UniqueOptions>() const* {
10949	return builtin_options_as_UniqueOptions();
10950	}
10951
10952	template<> inline const tflite::ReverseV2Options Operator::builtin_options_as<tflite::ReverseV2Options>() const* {
10953	return builtin_options_as_ReverseV2Options();
10954	}
10955
10956	template<> inline const tflite::AddNOptions Operator::builtin_options_as<tflite::AddNOptions>() const* {
10957	return builtin_options_as_AddNOptions();
10958	}
10959
10960	template<> inline const tflite::GatherNdOptions Operator::builtin_options_as<tflite::GatherNdOptions>() const* {
10961	return builtin_options_as_GatherNdOptions();
10962	}
10963
10964	template<> inline const tflite::CosOptions Operator::builtin_options_as<tflite::CosOptions>() const* {
10965	return builtin_options_as_CosOptions();
10966	}
10967
10968	template<> inline const tflite::WhereOptions Operator::builtin_options_as<tflite::WhereOptions>() const* {
10969	return builtin_options_as_WhereOptions();
10970	}
10971
10972	template<> inline const tflite::RankOptions Operator::builtin_options_as<tflite::RankOptions>() const* {
10973	return builtin_options_as_RankOptions();
10974	}
10975
10976	template<> inline const tflite::ReverseSequenceOptions Operator::builtin_options_as<tflite::ReverseSequenceOptions>() const* {
10977	return builtin_options_as_ReverseSequenceOptions();
10978	}
10979
10980	template<> inline const tflite::MatrixDiagOptions Operator::builtin_options_as<tflite::MatrixDiagOptions>() const* {
10981	return builtin_options_as_MatrixDiagOptions();
10982	}
10983
10984	template<> inline const tflite::QuantizeOptions Operator::builtin_options_as<tflite::QuantizeOptions>() const* {
10985	return builtin_options_as_QuantizeOptions();
10986	}
10987
10988	template<> inline const tflite::MatrixSetDiagOptions Operator::builtin_options_as<tflite::MatrixSetDiagOptions>() const* {
10989	return builtin_options_as_MatrixSetDiagOptions();
10990	}
10991
10992	template<> inline const tflite::HardSwishOptions Operator::builtin_options_as<tflite::HardSwishOptions>() const* {
10993	return builtin_options_as_HardSwishOptions();
10994	}
10995
10996	template<> inline const tflite::IfOptions Operator::builtin_options_as<tflite::IfOptions>() const* {
10997	return builtin_options_as_IfOptions();
10998	}
10999
11000	template<> inline const tflite::WhileOptions Operator::builtin_options_as<tflite::WhileOptions>() const* {
11001	return builtin_options_as_WhileOptions();
11002	}
11003
11004	template<> inline const tflite::DepthToSpaceOptions Operator::builtin_options_as<tflite::DepthToSpaceOptions>() const* {
11005	return builtin_options_as_DepthToSpaceOptions();
11006	}
11007
11008	template<> inline const tflite::NonMaxSuppressionV4Options Operator::builtin_options_as<tflite::NonMaxSuppressionV4Options>() const* {
11009	return builtin_options_as_NonMaxSuppressionV4Options();
11010	}
11011
11012	template<> inline const tflite::NonMaxSuppressionV5Options Operator::builtin_options_as<tflite::NonMaxSuppressionV5Options>() const* {
11013	return builtin_options_as_NonMaxSuppressionV5Options();
11014	}
11015
11016	template<> inline const tflite::ScatterNdOptions Operator::builtin_options_as<tflite::ScatterNdOptions>() const* {
11017	return builtin_options_as_ScatterNdOptions();
11018	}
11019
11020	template<> inline const tflite::SelectV2Options Operator::builtin_options_as<tflite::SelectV2Options>() const* {
11021	return builtin_options_as_SelectV2Options();
11022	}
11023
11024	template<> inline const tflite::DensifyOptions Operator::builtin_options_as<tflite::DensifyOptions>() const* {
11025	return builtin_options_as_DensifyOptions();
11026	}
11027
11028	template<> inline const tflite::SegmentSumOptions Operator::builtin_options_as<tflite::SegmentSumOptions>() const* {
11029	return builtin_options_as_SegmentSumOptions();
11030	}
11031
11032	template<> inline const tflite::BatchMatMulOptions Operator::builtin_options_as<tflite::BatchMatMulOptions>() const* {
11033	return builtin_options_as_BatchMatMulOptions();
11034	}
11035
11036	template<> inline const tflite::CumsumOptions Operator::builtin_options_as<tflite::CumsumOptions>() const* {
11037	return builtin_options_as_CumsumOptions();
11038	}
11039
11040	template<> inline const tflite::CallOnceOptions Operator::builtin_options_as<tflite::CallOnceOptions>() const* {
11041	return builtin_options_as_CallOnceOptions();
11042	}
11043
11044	template<> inline const tflite::BroadcastToOptions Operator::builtin_options_as<tflite::BroadcastToOptions>() const* {
11045	return builtin_options_as_BroadcastToOptions();
11046	}
11047
11048	template<> inline const tflite::Rfft2dOptions Operator::builtin_options_as<tflite::Rfft2dOptions>() const* {
11049	return builtin_options_as_Rfft2dOptions();
11050	}
11051
11052	template<> inline const tflite::Conv3DOptions Operator::builtin_options_as<tflite::Conv3DOptions>() const* {
11053	return builtin_options_as_Conv3DOptions();
11054	}
11055
11056	template<> inline const tflite::HashtableOptions Operator::builtin_options_as<tflite::HashtableOptions>() const* {
11057	return builtin_options_as_HashtableOptions();
11058	}
11059
11060	template<> inline const tflite::HashtableFindOptions Operator::builtin_options_as<tflite::HashtableFindOptions>() const* {
11061	return builtin_options_as_HashtableFindOptions();
11062	}
11063
11064	template<> inline const tflite::HashtableImportOptions Operator::builtin_options_as<tflite::HashtableImportOptions>() const* {
11065	return builtin_options_as_HashtableImportOptions();
11066	}
11067
11068	template<> inline const tflite::HashtableSizeOptions Operator::builtin_options_as<tflite::HashtableSizeOptions>() const* {
11069	return builtin_options_as_HashtableSizeOptions();
11070	}
11071
11072	struct OperatorBuilder {
11073	flatbuffers::FlatBufferBuilder &fbb_;
11074	flatbuffers::uoffset_t start_;
11075	void add_opcode_index(uint32_t opcode_index) {
11076	fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, `0`);
11077	}
11078	void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
11079	fbb_.AddOffset(Operator::VT_INPUTS, inputs);
11080	}
11081	void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
11082	fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
11083	}
11084	void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) {
11085	fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), `0`);
11086	}
11087	void add_builtin_options(flatbuffers::Offset<void> builtin_options) {
11088	fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
11089	}
11090	void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) {
11091	fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
11092	}
11093	void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format) {
11094	fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), `0`);
11095	}
11096	void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
11097	fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
11098	}
11099	void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates) {
11100	fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
11101	}
11102	explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11103	: fbb_(_fbb) {
11104	start_ = fbb_.StartTable();
11105	}
11106	OperatorBuilder &operator=(const OperatorBuilder &);
11107	flatbuffers::Offset<Operator> Finish() {
11108	const auto end = fbb_.EndTable(start_);
11109	auto o = flatbuffers::Offset<Operator>(end);
11110	return o;
11111	}
11112	};
11113
11114	inline flatbuffers::Offset<Operator> CreateOperator(
11115	flatbuffers::FlatBufferBuilder &_fbb,
11116	uint32_t opcode_index = `0`,
11117	flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = `0`,
11118	flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = `0`,
11119	tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
11120	flatbuffers::Offset<void> builtin_options = `0`,
11121	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = `0`,
11122	tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
11123	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = `0`,
11124	flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = `0`) {
11125	OperatorBuilder builder_(_fbb);
11126	builder_.add_intermediates(intermediates);
11127	builder_.add_mutating_variable_inputs(mutating_variable_inputs);
11128	builder_.add_custom_options(custom_options);
11129	builder_.add_builtin_options(builtin_options);
11130	builder_.add_outputs(outputs);
11131	builder_.add_inputs(inputs);
11132	builder_.add_opcode_index(opcode_index);
11133	builder_.add_custom_options_format(custom_options_format);
11134	builder_.add_builtin_options_type(builtin_options_type);
11135	return builder_.Finish();
11136	}
11137
11138	inline flatbuffers::Offset<Operator> CreateOperatorDirect(
11139	flatbuffers::FlatBufferBuilder &_fbb,
11140	uint32_t opcode_index = `0`,
11141	const std::vector<int32_t> inputs = nullptr*,
11142	const std::vector<int32_t> outputs = nullptr*,
11143	tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
11144	flatbuffers::Offset<void> builtin_options = `0`,
11145	const std::vector<uint8_t> custom_options = nullptr*,
11146	tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
11147	const std::vector<uint8_t> mutating_variable_inputs = nullptr*,
11148	const std::vector<int32_t> intermediates = nullptr*) {
11149	auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : `0`;
11150	auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : `0`;
11151	auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : `0`;
11152	auto mutating_variable_inputs__ = mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : `0`;
11153	auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : `0`;
11154	return tflite::CreateOperator(
11155	_fbb,
11156	opcode_index,
11157	inputs__,
11158	outputs__,
11159	builtin_options_type,
11160	builtin_options,
11161	custom_options__,
11162	custom_options_format,
11163	mutating_variable_inputs__,
11164	intermediates__);
11165	}
11166
11167	flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11168
11169	struct SubGraphT : public flatbuffers::NativeTable {
11170	typedef SubGraph TableType;
11171	std::vector<std::unique_ptr<tflite::TensorT>> tensors;
11172	std::vector<int32_t> inputs;
11173	std::vector<int32_t> outputs;
11174	std::vector<std::unique_ptr<tflite::OperatorT>> operators;
11175	std::string name;
11176	SubGraphT() {
11177	}
11178	};
11179
11180	struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11181	typedef SubGraphT NativeTableType;
11182	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11183	VT_TENSORS = `4`,
11184	VT_INPUTS = `6`,
11185	VT_OUTPUTS = `8`,
11186	VT_OPERATORS = `10`,
11187	VT_NAME = `12`
11188	};
11189	const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> tensors() const* {
11190	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
11191	}
11192	const flatbuffers::Vector<int32_t> inputs() const* {
11193	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
11194	}
11195	const flatbuffers::Vector<int32_t> outputs() const* {
11196	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
11197	}
11198	const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> operators() const* {
11199	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
11200	}
11201	const flatbuffers::String name() const* {
11202	return GetPointer<const flatbuffers::String *>(VT_NAME);
11203	}
11204	bool Verify(flatbuffers::Verifier &verifier) const {
11205	return VerifyTableStart(verifier) &&
11206	VerifyOffset(verifier, VT_TENSORS) &&
11207	verifier.VerifyVector(tensors()) &&
11208	verifier.VerifyVectorOfTables(tensors()) &&
11209	VerifyOffset(verifier, VT_INPUTS) &&
11210	verifier.VerifyVector(inputs()) &&
11211	VerifyOffset(verifier, VT_OUTPUTS) &&
11212	verifier.VerifyVector(outputs()) &&
11213	VerifyOffset(verifier, VT_OPERATORS) &&
11214	verifier.VerifyVector(operators()) &&
11215	verifier.VerifyVectorOfTables(operators()) &&
11216	VerifyOffset(verifier, VT_NAME) &&
11217	verifier.VerifyString(name()) &&
11218	verifier.EndTable();
11219	}
11220	SubGraphT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11221	void UnPackTo(SubGraphT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11222	static flatbuffers::Offset<SubGraph> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11223	};
11224
11225	struct SubGraphBuilder {
11226	flatbuffers::FlatBufferBuilder &fbb_;
11227	flatbuffers::uoffset_t start_;
11228	void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors) {
11229	fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
11230	}
11231	void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
11232	fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
11233	}
11234	void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
11235	fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
11236	}
11237	void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators) {
11238	fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
11239	}
11240	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
11241	fbb_.AddOffset(SubGraph::VT_NAME, name);
11242	}
11243	explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11244	: fbb_(_fbb) {
11245	start_ = fbb_.StartTable();
11246	}
11247	SubGraphBuilder &operator=(const SubGraphBuilder &);
11248	flatbuffers::Offset<SubGraph> Finish() {
11249	const auto end = fbb_.EndTable(start_);
11250	auto o = flatbuffers::Offset<SubGraph>(end);
11251	return o;
11252	}
11253	};
11254
11255	inline flatbuffers::Offset<SubGraph> CreateSubGraph(
11256	flatbuffers::FlatBufferBuilder &_fbb,
11257	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors = `0`,
11258	flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = `0`,
11259	flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = `0`,
11260	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators = `0`,
11261	flatbuffers::Offset<flatbuffers::String> name = `0`) {
11262	SubGraphBuilder builder_(_fbb);
11263	builder_.add_name(name);
11264	builder_.add_operators(operators);
11265	builder_.add_outputs(outputs);
11266	builder_.add_inputs(inputs);
11267	builder_.add_tensors(tensors);
11268	return builder_.Finish();
11269	}
11270
11271	inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
11272	flatbuffers::FlatBufferBuilder &_fbb,
11273	const std::vector<flatbuffers::Offset<tflite::Tensor>> tensors = nullptr*,
11274	const std::vector<int32_t> inputs = nullptr*,
11275	const std::vector<int32_t> outputs = nullptr*,
11276	const std::vector<flatbuffers::Offset<tflite::Operator>> operators = nullptr*,
11277	const char name = nullptr*) {
11278	auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>>(*tensors) : `0`;
11279	auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : `0`;
11280	auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : `0`;
11281	auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>>(*operators) : `0`;
11282	auto name__ = name ? _fbb.CreateString(name) : `0`;
11283	return tflite::CreateSubGraph(
11284	_fbb,
11285	tensors__,
11286	inputs__,
11287	outputs__,
11288	operators__,
11289	name__);
11290	}
11291
11292	flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11293
11294	struct BufferT : public flatbuffers::NativeTable {
11295	typedef Buffer TableType;
11296	std::vector<uint8_t> data;
11297	BufferT() {
11298	}
11299	};
11300
11301	struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11302	typedef BufferT NativeTableType;
11303	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11304	VT_DATA = `4`
11305	};
11306	const flatbuffers::Vector<uint8_t> data() const* {
11307	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
11308	}
11309	bool Verify(flatbuffers::Verifier &verifier) const {
11310	return VerifyTableStart(verifier) &&
11311	VerifyOffset(verifier, VT_DATA) &&
11312	verifier.VerifyVector(data()) &&
11313	verifier.EndTable();
11314	}
11315	BufferT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11316	void UnPackTo(BufferT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11317	static flatbuffers::Offset<Buffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11318	};
11319
11320	struct BufferBuilder {
11321	flatbuffers::FlatBufferBuilder &fbb_;
11322	flatbuffers::uoffset_t start_;
11323	void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
11324	fbb_.AddOffset(Buffer::VT_DATA, data);
11325	}
11326	explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11327	: fbb_(_fbb) {
11328	start_ = fbb_.StartTable();
11329	}
11330	BufferBuilder &operator=(const BufferBuilder &);
11331	flatbuffers::Offset<Buffer> Finish() {
11332	const auto end = fbb_.EndTable(start_);
11333	auto o = flatbuffers::Offset<Buffer>(end);
11334	return o;
11335	}
11336	};
11337
11338	inline flatbuffers::Offset<Buffer> CreateBuffer(
11339	flatbuffers::FlatBufferBuilder &_fbb,
11340	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = `0`) {
11341	BufferBuilder builder_(_fbb);
11342	builder_.add_data(data);
11343	return builder_.Finish();
11344	}
11345
11346	inline flatbuffers::Offset<Buffer> CreateBufferDirect(
11347	flatbuffers::FlatBufferBuilder &_fbb,
11348	const std::vector<uint8_t> data = nullptr*) {
11349	if (data) { _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), `16`); }
11350	auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : `0`;
11351	return tflite::CreateBuffer(
11352	_fbb,
11353	data__);
11354	}
11355
11356	flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11357
11358	struct MetadataT : public flatbuffers::NativeTable {
11359	typedef Metadata TableType;
11360	std::string name;
11361	uint32_t buffer;
11362	MetadataT()
11363	: buffer(`0`) {
11364	}
11365	};
11366
11367	struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11368	typedef MetadataT NativeTableType;
11369	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11370	VT_NAME = `4`,
11371	VT_BUFFER = `6`
11372	};
11373	const flatbuffers::String name() const* {
11374	return GetPointer<const flatbuffers::String *>(VT_NAME);
11375	}
11376	uint32_t buffer() const {
11377	return GetField<uint32_t>(VT_BUFFER, `0`);
11378	}
11379	bool Verify(flatbuffers::Verifier &verifier) const {
11380	return VerifyTableStart(verifier) &&
11381	VerifyOffset(verifier, VT_NAME) &&
11382	verifier.VerifyString(name()) &&
11383	VerifyField<uint32_t>(verifier, VT_BUFFER) &&
11384	verifier.EndTable();
11385	}
11386	MetadataT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11387	void UnPackTo(MetadataT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11388	static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11389	};
11390
11391	struct MetadataBuilder {
11392	flatbuffers::FlatBufferBuilder &fbb_;
11393	flatbuffers::uoffset_t start_;
11394	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
11395	fbb_.AddOffset(Metadata::VT_NAME, name);
11396	}
11397	void add_buffer(uint32_t buffer) {
11398	fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, `0`);
11399	}
11400	explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11401	: fbb_(_fbb) {
11402	start_ = fbb_.StartTable();
11403	}
11404	MetadataBuilder &operator=(const MetadataBuilder &);
11405	flatbuffers::Offset<Metadata> Finish() {
11406	const auto end = fbb_.EndTable(start_);
11407	auto o = flatbuffers::Offset<Metadata>(end);
11408	return o;
11409	}
11410	};
11411
11412	inline flatbuffers::Offset<Metadata> CreateMetadata(
11413	flatbuffers::FlatBufferBuilder &_fbb,
11414	flatbuffers::Offset<flatbuffers::String> name = `0`,
11415	uint32_t buffer = `0`) {
11416	MetadataBuilder builder_(_fbb);
11417	builder_.add_buffer(buffer);
11418	builder_.add_name(name);
11419	return builder_.Finish();
11420	}
11421
11422	inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
11423	flatbuffers::FlatBufferBuilder &_fbb,
11424	const char name = nullptr*,
11425	uint32_t buffer = `0`) {
11426	auto name__ = name ? _fbb.CreateString(name) : `0`;
11427	return tflite::CreateMetadata(
11428	_fbb,
11429	name__,
11430	buffer);
11431	}
11432
11433	flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11434
11435	struct TensorMapT : public flatbuffers::NativeTable {
11436	typedef TensorMap TableType;
11437	std::string name;
11438	uint32_t tensor_index;
11439	TensorMapT()
11440	: tensor_index(`0`) {
11441	}
11442	};
11443
11444	struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11445	typedef TensorMapT NativeTableType;
11446	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11447	VT_NAME = `4`,
11448	VT_TENSOR_INDEX = `6`
11449	};
11450	const flatbuffers::String name() const* {
11451	return GetPointer<const flatbuffers::String *>(VT_NAME);
11452	}
11453	uint32_t tensor_index() const {
11454	return GetField<uint32_t>(VT_TENSOR_INDEX, `0`);
11455	}
11456	bool Verify(flatbuffers::Verifier &verifier) const {
11457	return VerifyTableStart(verifier) &&
11458	VerifyOffset(verifier, VT_NAME) &&
11459	verifier.VerifyString(name()) &&
11460	VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX) &&
11461	verifier.EndTable();
11462	}
11463	TensorMapT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11464	void UnPackTo(TensorMapT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11465	static flatbuffers::Offset<TensorMap> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11466	};
11467
11468	struct TensorMapBuilder {
11469	flatbuffers::FlatBufferBuilder &fbb_;
11470	flatbuffers::uoffset_t start_;
11471	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
11472	fbb_.AddOffset(TensorMap::VT_NAME, name);
11473	}
11474	void add_tensor_index(uint32_t tensor_index) {
11475	fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, `0`);
11476	}
11477	explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11478	: fbb_(_fbb) {
11479	start_ = fbb_.StartTable();
11480	}
11481	TensorMapBuilder &operator=(const TensorMapBuilder &);
11482	flatbuffers::Offset<TensorMap> Finish() {
11483	const auto end = fbb_.EndTable(start_);
11484	auto o = flatbuffers::Offset<TensorMap>(end);
11485	return o;
11486	}
11487	};
11488
11489	inline flatbuffers::Offset<TensorMap> CreateTensorMap(
11490	flatbuffers::FlatBufferBuilder &_fbb,
11491	flatbuffers::Offset<flatbuffers::String> name = `0`,
11492	uint32_t tensor_index = `0`) {
11493	TensorMapBuilder builder_(_fbb);
11494	builder_.add_tensor_index(tensor_index);
11495	builder_.add_name(name);
11496	return builder_.Finish();
11497	}
11498
11499	inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
11500	flatbuffers::FlatBufferBuilder &_fbb,
11501	const char name = nullptr*,
11502	uint32_t tensor_index = `0`) {
11503	auto name__ = name ? _fbb.CreateString(name) : `0`;
11504	return tflite::CreateTensorMap(
11505	_fbb,
11506	name__,
11507	tensor_index);
11508	}
11509
11510	flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11511
11512	struct SignatureDefT : public flatbuffers::NativeTable {
11513	typedef SignatureDef TableType;
11514	std::vector<std::unique_ptr<tflite::TensorMapT>> inputs;
11515	std::vector<std::unique_ptr<tflite::TensorMapT>> outputs;
11516	std::string method_name;
11517	std::string key;
11518	SignatureDefT() {
11519	}
11520	};
11521
11522	struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11523	typedef SignatureDefT NativeTableType;
11524	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11525	VT_INPUTS = `4`,
11526	VT_OUTPUTS = `6`,
11527	VT_METHOD_NAME = `8`,
11528	VT_KEY = `10`
11529	};
11530	const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> inputs() const* {
11531	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
11532	}
11533	const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> outputs() const* {
11534	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
11535	}
11536	const flatbuffers::String method_name() const* {
11537	return GetPointer<const flatbuffers::String *>(VT_METHOD_NAME);
11538	}
11539	const flatbuffers::String key() const* {
11540	return GetPointer<const flatbuffers::String *>(VT_KEY);
11541	}
11542	bool Verify(flatbuffers::Verifier &verifier) const {
11543	return VerifyTableStart(verifier) &&
11544	VerifyOffset(verifier, VT_INPUTS) &&
11545	verifier.VerifyVector(inputs()) &&
11546	verifier.VerifyVectorOfTables(inputs()) &&
11547	VerifyOffset(verifier, VT_OUTPUTS) &&
11548	verifier.VerifyVector(outputs()) &&
11549	verifier.VerifyVectorOfTables(outputs()) &&
11550	VerifyOffset(verifier, VT_METHOD_NAME) &&
11551	verifier.VerifyString(method_name()) &&
11552	VerifyOffset(verifier, VT_KEY) &&
11553	verifier.VerifyString(key()) &&
11554	verifier.EndTable();
11555	}
11556	SignatureDefT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11557	void UnPackTo(SignatureDefT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11558	static flatbuffers::Offset<SignatureDef> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11559	};
11560
11561	struct SignatureDefBuilder {
11562	flatbuffers::FlatBufferBuilder &fbb_;
11563	flatbuffers::uoffset_t start_;
11564	void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs) {
11565	fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
11566	}
11567	void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs) {
11568	fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
11569	}
11570	void add_method_name(flatbuffers::Offset<flatbuffers::String> method_name) {
11571	fbb_.AddOffset(SignatureDef::VT_METHOD_NAME, method_name);
11572	}
11573	void add_key(flatbuffers::Offset<flatbuffers::String> key) {
11574	fbb_.AddOffset(SignatureDef::VT_KEY, key);
11575	}
11576	explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11577	: fbb_(_fbb) {
11578	start_ = fbb_.StartTable();
11579	}
11580	SignatureDefBuilder &operator=(const SignatureDefBuilder &);
11581	flatbuffers::Offset<SignatureDef> Finish() {
11582	const auto end = fbb_.EndTable(start_);
11583	auto o = flatbuffers::Offset<SignatureDef>(end);
11584	return o;
11585	}
11586	};
11587
11588	inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
11589	flatbuffers::FlatBufferBuilder &_fbb,
11590	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs = `0`,
11591	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs = `0`,
11592	flatbuffers::Offset<flatbuffers::String> method_name = `0`,
11593	flatbuffers::Offset<flatbuffers::String> key = `0`) {
11594	SignatureDefBuilder builder_(_fbb);
11595	builder_.add_key(key);
11596	builder_.add_method_name(method_name);
11597	builder_.add_outputs(outputs);
11598	builder_.add_inputs(inputs);
11599	return builder_.Finish();
11600	}
11601
11602	inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
11603	flatbuffers::FlatBufferBuilder &_fbb,
11604	const std::vector<flatbuffers::Offset<tflite::TensorMap>> inputs = nullptr*,
11605	const std::vector<flatbuffers::Offset<tflite::TensorMap>> outputs = nullptr*,
11606	const char method_name = nullptr*,
11607	const char key = nullptr*) {
11608	auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*inputs) : `0`;
11609	auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*outputs) : `0`;
11610	auto method_name__ = method_name ? _fbb.CreateString(method_name) : `0`;
11611	auto key__ = key ? _fbb.CreateString(key) : `0`;
11612	return tflite::CreateSignatureDef(
11613	_fbb,
11614	inputs__,
11615	outputs__,
11616	method_name__,
11617	key__);
11618	}
11619
11620	flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11621
11622	struct ModelT : public flatbuffers::NativeTable {
11623	typedef Model TableType;
11624	uint32_t version;
11625	std::vector<std::unique_ptr<tflite::OperatorCodeT>> operator_codes;
11626	std::vector<std::unique_ptr<tflite::SubGraphT>> subgraphs;
11627	std::string description;
11628	std::vector<std::unique_ptr<tflite::BufferT>> buffers;
11629	std::vector<int32_t> metadata_buffer;
11630	std::vector<std::unique_ptr<tflite::MetadataT>> metadata;
11631	std::vector<std::unique_ptr<tflite::SignatureDefT>> signature_defs;
11632	ModelT()
11633	: version(`0`) {
11634	}
11635	};
11636
11637	struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11638	typedef ModelT NativeTableType;
11639	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11640	VT_VERSION = `4`,
11641	VT_OPERATOR_CODES = `6`,
11642	VT_SUBGRAPHS = `8`,
11643	VT_DESCRIPTION = `10`,
11644	VT_BUFFERS = `12`,
11645	VT_METADATA_BUFFER = `14`,
11646	VT_METADATA = `16`,
11647	VT_SIGNATURE_DEFS = `18`
11648	};
11649	uint32_t version() const {
11650	return GetField<uint32_t>(VT_VERSION, `0`);
11651	}
11652	const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> operator_codes() const* {
11653	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
11654	}
11655	const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> subgraphs() const* {
11656	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
11657	}
11658	const flatbuffers::String description() const* {
11659	return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
11660	}
11661	const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> buffers() const* {
11662	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
11663	}
11664	const flatbuffers::Vector<int32_t> metadata_buffer() const* {
11665	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
11666	}
11667	const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> metadata() const* {
11668	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
11669	}
11670	const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> signature_defs() const* {
11671	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
11672	}
11673	bool Verify(flatbuffers::Verifier &verifier) const {
11674	return VerifyTableStart(verifier) &&
11675	VerifyField<uint32_t>(verifier, VT_VERSION) &&
11676	VerifyOffset(verifier, VT_OPERATOR_CODES) &&
11677	verifier.VerifyVector(operator_codes()) &&
11678	verifier.VerifyVectorOfTables(operator_codes()) &&
11679	VerifyOffset(verifier, VT_SUBGRAPHS) &&
11680	verifier.VerifyVector(subgraphs()) &&
11681	verifier.VerifyVectorOfTables(subgraphs()) &&
11682	VerifyOffset(verifier, VT_DESCRIPTION) &&
11683	verifier.VerifyString(description()) &&
11684	VerifyOffset(verifier, VT_BUFFERS) &&
11685	verifier.VerifyVector(buffers()) &&
11686	verifier.VerifyVectorOfTables(buffers()) &&
11687	VerifyOffset(verifier, VT_METADATA_BUFFER) &&
11688	verifier.VerifyVector(metadata_buffer()) &&
11689	VerifyOffset(verifier, VT_METADATA) &&
11690	verifier.VerifyVector(metadata()) &&
11691	verifier.VerifyVectorOfTables(metadata()) &&
11692	VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
11693	verifier.VerifyVector(signature_defs()) &&
11694	verifier.VerifyVectorOfTables(signature_defs()) &&
11695	verifier.EndTable();
11696	}
11697	ModelT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11698	void UnPackTo(ModelT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11699	static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11700	};
11701
11702	struct ModelBuilder {
11703	flatbuffers::FlatBufferBuilder &fbb_;
11704	flatbuffers::uoffset_t start_;
11705	void add_version(uint32_t version) {
11706	fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, `0`);
11707	}
11708	void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
11709	fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
11710	}
11711	void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
11712	fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
11713	}
11714	void add_description(flatbuffers::Offset<flatbuffers::String> description) {
11715	fbb_.AddOffset(Model::VT_DESCRIPTION, description);
11716	}
11717	void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers) {
11718	fbb_.AddOffset(Model::VT_BUFFERS, buffers);
11719	}
11720	void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) {
11721	fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
11722	}
11723	void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata) {
11724	fbb_.AddOffset(Model::VT_METADATA, metadata);
11725	}
11726	void add_signature_defs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs) {
11727	fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
11728	}
11729	explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11730	: fbb_(_fbb) {
11731	start_ = fbb_.StartTable();
11732	}
11733	ModelBuilder &operator=(const ModelBuilder &);
11734	flatbuffers::Offset<Model> Finish() {
11735	const auto end = fbb_.EndTable(start_);
11736	auto o = flatbuffers::Offset<Model>(end);
11737	return o;
11738	}
11739	};
11740
11741	inline flatbuffers::Offset<Model> CreateModel(
11742	flatbuffers::FlatBufferBuilder &_fbb,
11743	uint32_t version = `0`,
11744	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = `0`,
11745	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs = `0`,
11746	flatbuffers::Offset<flatbuffers::String> description = `0`,
11747	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers = `0`,
11748	flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = `0`,
11749	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata = `0`,
11750	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = `0`) {
11751	ModelBuilder builder_(_fbb);
11752	builder_.add_signature_defs(signature_defs);
11753	builder_.add_metadata(metadata);
11754	builder_.add_metadata_buffer(metadata_buffer);
11755	builder_.add_buffers(buffers);
11756	builder_.add_description(description);
11757	builder_.add_subgraphs(subgraphs);
11758	builder_.add_operator_codes(operator_codes);
11759	builder_.add_version(version);
11760	return builder_.Finish();
11761	}
11762
11763	inline flatbuffers::Offset<Model> CreateModelDirect(
11764	flatbuffers::FlatBufferBuilder &_fbb,
11765	uint32_t version = `0`,
11766	const std::vector<flatbuffers::Offset<tflite::OperatorCode>> operator_codes = nullptr*,
11767	const std::vector<flatbuffers::Offset<tflite::SubGraph>> subgraphs = nullptr*,
11768	const char description = nullptr*,
11769	const std::vector<flatbuffers::Offset<tflite::Buffer>> buffers = nullptr*,
11770	const std::vector<int32_t> metadata_buffer = nullptr*,
11771	const std::vector<flatbuffers::Offset<tflite::Metadata>> metadata = nullptr*,
11772	const std::vector<flatbuffers::Offset<tflite::SignatureDef>> signature_defs = nullptr*) {
11773	auto operator_codes__ = operator_codes ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : `0`;
11774	auto subgraphs__ = subgraphs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : `0`;
11775	auto description__ = description ? _fbb.CreateString(description) : `0`;
11776	auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>>(*buffers) : `0`;
11777	auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : `0`;
11778	auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>>(*metadata) : `0`;
11779	auto signature_defs__ = signature_defs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : `0`;
11780	return tflite::CreateModel(
11781	_fbb,
11782	version,
11783	operator_codes__,
11784	subgraphs__,
11785	description__,
11786	buffers__,
11787	metadata_buffer__,
11788	metadata__,
11789	signature_defs__);
11790	}
11791
11792	flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11793
11794	inline CustomQuantizationT CustomQuantization::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11795	auto _o = new CustomQuantizationT ();
11796	UnPackTo(_o, _resolver);
11797	return _o;
11798	}
11799
11800	inline void CustomQuantization::UnPackTo(CustomQuantizationT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11801	(void)_o;
11802	(void)_resolver;
11803	{ auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom.begin()); } }
11804	}
11805
11806	inline flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11807	return CreateCustomQuantization(_fbb, _o, _rehasher);
11808	}
11809
11810	inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
11811	(void)_rehasher;
11812	(void)_o;
11813	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CustomQuantizationT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
11814	_fbb.ForceVectorAlignment(_o->custom.size(), sizeof(uint8_t), `16`);
11815	auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : `0`;
11816	return tflite::CreateCustomQuantization(
11817	_fbb,
11818	_custom);
11819	}
11820
11821	inline QuantizationParametersT QuantizationParameters::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11822	auto _o = new QuantizationParametersT ();
11823	UnPackTo(_o, _resolver);
11824	return _o;
11825	}
11826
11827	inline void QuantizationParameters::UnPackTo(QuantizationParametersT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11828	(void)_o;
11829	(void)_resolver;
11830	{ auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->min[_i] = _e->Get(_i); } } }
11831	{ auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->max[_i] = _e->Get(_i); } } }
11832	{ auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } }
11833	{ auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } }
11834	{ auto _e = details_type(); _o->details.type = _e; }
11835	{ auto _e = details(); if (_e) _o->details.value = tflite::QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); }
11836	{ auto _e = quantized_dimension(); _o->quantized_dimension = _e; }
11837	}
11838
11839	inline flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11840	return CreateQuantizationParameters(_fbb, _o, _rehasher);
11841	}
11842
11843	inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
11844	(void)_rehasher;
11845	(void)_o;
11846	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* QuantizationParametersT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
11847	auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : `0`;
11848	auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : `0`;
11849	auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : `0`;
11850	auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : `0`;
11851	auto _details_type = _o->details.type;
11852	auto _details = _o->details.Pack(_fbb);
11853	auto _quantized_dimension = _o->quantized_dimension;
11854	return tflite::CreateQuantizationParameters(
11855	_fbb,
11856	_min,
11857	_max,
11858	_scale,
11859	_zero_point,
11860	_details_type,
11861	_details,
11862	_quantized_dimension);
11863	}
11864
11865	inline Int32VectorT Int32Vector::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11866	auto _o = new Int32VectorT ();
11867	UnPackTo(_o, _resolver);
11868	return _o;
11869	}
11870
11871	inline void Int32Vector::UnPackTo(Int32VectorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11872	(void)_o;
11873	(void)_resolver;
11874	{ auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
11875	}
11876
11877	inline flatbuffers::Offset<Int32Vector> Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11878	return CreateInt32Vector(_fbb, _o, _rehasher);
11879	}
11880
11881	inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
11882	(void)_rehasher;
11883	(void)_o;
11884	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Int32VectorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
11885	auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : `0`;
11886	return tflite::CreateInt32Vector(
11887	_fbb,
11888	_values);
11889	}
11890
11891	inline Uint16VectorT Uint16Vector::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11892	auto _o = new Uint16VectorT ();
11893	UnPackTo(_o, _resolver);
11894	return _o;
11895	}
11896
11897	inline void Uint16Vector::UnPackTo(Uint16VectorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11898	(void)_o;
11899	(void)_resolver;
11900	{ auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
11901	}
11902
11903	inline flatbuffers::Offset<Uint16Vector> Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11904	return CreateUint16Vector(_fbb, _o, _rehasher);
11905	}
11906
11907	inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
11908	(void)_rehasher;
11909	(void)_o;
11910	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Uint16VectorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
11911	_fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint16_t), `4`);
11912	auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : `0`;
11913	return tflite::CreateUint16Vector(
11914	_fbb,
11915	_values);
11916	}
11917
11918	inline Uint8VectorT Uint8Vector::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11919	auto _o = new Uint8VectorT ();
11920	UnPackTo(_o, _resolver);
11921	return _o;
11922	}
11923
11924	inline void Uint8Vector::UnPackTo(Uint8VectorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11925	(void)_o;
11926	(void)_resolver;
11927	{ auto _e = values(); if (_e) { _o->values.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->values.begin()); } }
11928	}
11929
11930	inline flatbuffers::Offset<Uint8Vector> Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11931	return CreateUint8Vector(_fbb, _o, _rehasher);
11932	}
11933
11934	inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
11935	(void)_rehasher;
11936	(void)_o;
11937	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Uint8VectorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
11938	_fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint8_t), `4`);
11939	auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : `0`;
11940	return tflite::CreateUint8Vector(
11941	_fbb,
11942	_values);
11943	}
11944
11945	inline DimensionMetadataT DimensionMetadata::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11946	auto _o = new DimensionMetadataT ();
11947	UnPackTo(_o, _resolver);
11948	return _o;
11949	}
11950
11951	inline void DimensionMetadata::UnPackTo(DimensionMetadataT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11952	(void)_o;
11953	(void)_resolver;
11954	{ auto _e = format(); _o->format = _e; }
11955	{ auto _e = dense_size(); _o->dense_size = _e; }
11956	{ auto _e = array_segments_type(); _o->array_segments.type = _e; }
11957	{ auto _e = array_segments(); if (_e) _o->array_segments.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_segments_type(), _resolver); }
11958	{ auto _e = array_indices_type(); _o->array_indices.type = _e; }
11959	{ auto _e = array_indices(); if (_e) _o->array_indices.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver); }
11960	}
11961
11962	inline flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
11963	return CreateDimensionMetadata(_fbb, _o, _rehasher);
11964	}
11965
11966	inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
11967	(void)_rehasher;
11968	(void)_o;
11969	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DimensionMetadataT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
11970	auto _format = _o->format;
11971	auto _dense_size = _o->dense_size;
11972	auto _array_segments_type = _o->array_segments.type;
11973	auto _array_segments = _o->array_segments.Pack(_fbb);
11974	auto _array_indices_type = _o->array_indices.type;
11975	auto _array_indices = _o->array_indices.Pack(_fbb);
11976	return tflite::CreateDimensionMetadata(
11977	_fbb,
11978	_format,
11979	_dense_size,
11980	_array_segments_type,
11981	_array_segments,
11982	_array_indices_type,
11983	_array_indices);
11984	}
11985
11986	inline SparsityParametersT SparsityParameters::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
11987	auto _o = new SparsityParametersT ();
11988	UnPackTo(_o, _resolver);
11989	return _o;
11990	}
11991
11992	inline void SparsityParameters::UnPackTo(SparsityParametersT _o, const* flatbuffers::resolver_function_t _resolver) const* {
11993	(void)_o;
11994	(void)_resolver;
11995	{ auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } }
11996	{ auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->block_map[_i] = _e->Get(_i); } } }
11997	{ auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->dim_metadata[_i] = std::unique_ptr<tflite::DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
11998	}
11999
12000	inline flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12001	return CreateSparsityParameters(_fbb, _o, _rehasher);
12002	}
12003
12004	inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12005	(void)_rehasher;
12006	(void)_o;
12007	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SparsityParametersT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12008	auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : `0`;
12009	auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : `0`;
12010	auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>> (_o->dim_metadata.size(), [](size_t i, _VectorArgs __va) { return* CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher); }, &_va ) : `0`;
12011	return tflite::CreateSparsityParameters(
12012	_fbb,
12013	_traversal_order,
12014	_block_map,
12015	_dim_metadata);
12016	}
12017
12018	inline TensorT Tensor::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12019	auto _o = new TensorT ();
12020	UnPackTo(_o, _resolver);
12021	return _o;
12022	}
12023
12024	inline void Tensor::UnPackTo(TensorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12025	(void)_o;
12026	(void)_resolver;
12027	{ auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } }
12028	{ auto _e = type(); _o->type = _e; }
12029	{ auto _e = buffer(); _o->buffer = _e; }
12030	{ auto _e = name(); if (_e) _o->name = _e->str(); }
12031	{ auto _e = quantization(); if (_e) _o->quantization = std::unique_ptr<tflite::QuantizationParametersT>(_e->UnPack(_resolver)); }
12032	{ auto _e = is_variable(); _o->is_variable = _e; }
12033	{ auto _e = sparsity(); if (_e) _o->sparsity = std::unique_ptr<tflite::SparsityParametersT>(_e->UnPack(_resolver)); }
12034	{ auto _e = shape_signature(); if (_e) { _o->shape_signature.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->shape_signature[_i] = _e->Get(_i); } } }
12035	}
12036
12037	inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12038	return CreateTensor(_fbb, _o, _rehasher);
12039	}
12040
12041	inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12042	(void)_rehasher;
12043	(void)_o;
12044	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TensorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12045	auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : `0`;
12046	auto _type = _o->type;
12047	auto _buffer = _o->buffer;
12048	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
12049	auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : `0`;
12050	auto _is_variable = _o->is_variable;
12051	auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : `0`;
12052	auto _shape_signature = _o->shape_signature.size() ? _fbb.CreateVector(_o->shape_signature) : `0`;
12053	return tflite::CreateTensor(
12054	_fbb,
12055	_shape,
12056	_type,
12057	_buffer,
12058	_name,
12059	_quantization,
12060	_is_variable,
12061	_sparsity,
12062	_shape_signature);
12063	}
12064
12065	inline Conv2DOptionsT Conv2DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12066	auto _o = new Conv2DOptionsT ();
12067	UnPackTo(_o, _resolver);
12068	return _o;
12069	}
12070
12071	inline void Conv2DOptions::UnPackTo(Conv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12072	(void)_o;
12073	(void)_resolver;
12074	{ auto _e = padding(); _o->padding = _e; }
12075	{ auto _e = stride_w(); _o->stride_w = _e; }
12076	{ auto _e = stride_h(); _o->stride_h = _e; }
12077	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12078	{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
12079	{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
12080	}
12081
12082	inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12083	return CreateConv2DOptions(_fbb, _o, _rehasher);
12084	}
12085
12086	inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12087	(void)_rehasher;
12088	(void)_o;
12089	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12090	auto _padding = _o->padding;
12091	auto _stride_w = _o->stride_w;
12092	auto _stride_h = _o->stride_h;
12093	auto _fused_activation_function = _o->fused_activation_function;
12094	auto _dilation_w_factor = _o->dilation_w_factor;
12095	auto _dilation_h_factor = _o->dilation_h_factor;
12096	return tflite::CreateConv2DOptions(
12097	_fbb,
12098	_padding,
12099	_stride_w,
12100	_stride_h,
12101	_fused_activation_function,
12102	_dilation_w_factor,
12103	_dilation_h_factor);
12104	}
12105
12106	inline Conv3DOptionsT Conv3DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12107	auto _o = new Conv3DOptionsT ();
12108	UnPackTo(_o, _resolver);
12109	return _o;
12110	}
12111
12112	inline void Conv3DOptions::UnPackTo(Conv3DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12113	(void)_o;
12114	(void)_resolver;
12115	{ auto _e = padding(); _o->padding = _e; }
12116	{ auto _e = stride_d(); _o->stride_d = _e; }
12117	{ auto _e = stride_w(); _o->stride_w = _e; }
12118	{ auto _e = stride_h(); _o->stride_h = _e; }
12119	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12120	{ auto _e = dilation_d_factor(); _o->dilation_d_factor = _e; }
12121	{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
12122	{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
12123	}
12124
12125	inline flatbuffers::Offset<Conv3DOptions> Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12126	return CreateConv3DOptions(_fbb, _o, _rehasher);
12127	}
12128
12129	inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12130	(void)_rehasher;
12131	(void)_o;
12132	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Conv3DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12133	auto _padding = _o->padding;
12134	auto _stride_d = _o->stride_d;
12135	auto _stride_w = _o->stride_w;
12136	auto _stride_h = _o->stride_h;
12137	auto _fused_activation_function = _o->fused_activation_function;
12138	auto _dilation_d_factor = _o->dilation_d_factor;
12139	auto _dilation_w_factor = _o->dilation_w_factor;
12140	auto _dilation_h_factor = _o->dilation_h_factor;
12141	return tflite::CreateConv3DOptions(
12142	_fbb,
12143	_padding,
12144	_stride_d,
12145	_stride_w,
12146	_stride_h,
12147	_fused_activation_function,
12148	_dilation_d_factor,
12149	_dilation_w_factor,
12150	_dilation_h_factor);
12151	}
12152
12153	inline Pool2DOptionsT Pool2DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12154	auto _o = new Pool2DOptionsT ();
12155	UnPackTo(_o, _resolver);
12156	return _o;
12157	}
12158
12159	inline void Pool2DOptions::UnPackTo(Pool2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12160	(void)_o;
12161	(void)_resolver;
12162	{ auto _e = padding(); _o->padding = _e; }
12163	{ auto _e = stride_w(); _o->stride_w = _e; }
12164	{ auto _e = stride_h(); _o->stride_h = _e; }
12165	{ auto _e = filter_width(); _o->filter_width = _e; }
12166	{ auto _e = filter_height(); _o->filter_height = _e; }
12167	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12168	}
12169
12170	inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12171	return CreatePool2DOptions(_fbb, _o, _rehasher);
12172	}
12173
12174	inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12175	(void)_rehasher;
12176	(void)_o;
12177	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12178	auto _padding = _o->padding;
12179	auto _stride_w = _o->stride_w;
12180	auto _stride_h = _o->stride_h;
12181	auto _filter_width = _o->filter_width;
12182	auto _filter_height = _o->filter_height;
12183	auto _fused_activation_function = _o->fused_activation_function;
12184	return tflite::CreatePool2DOptions(
12185	_fbb,
12186	_padding,
12187	_stride_w,
12188	_stride_h,
12189	_filter_width,
12190	_filter_height,
12191	_fused_activation_function);
12192	}
12193
12194	inline DepthwiseConv2DOptionsT DepthwiseConv2DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12195	auto _o = new DepthwiseConv2DOptionsT ();
12196	UnPackTo(_o, _resolver);
12197	return _o;
12198	}
12199
12200	inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12201	(void)_o;
12202	(void)_resolver;
12203	{ auto _e = padding(); _o->padding = _e; }
12204	{ auto _e = stride_w(); _o->stride_w = _e; }
12205	{ auto _e = stride_h(); _o->stride_h = _e; }
12206	{ auto _e = depth_multiplier(); _o->depth_multiplier = _e; }
12207	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12208	{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
12209	{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
12210	}
12211
12212	inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12213	return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
12214	}
12215
12216	inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12217	(void)_rehasher;
12218	(void)_o;
12219	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12220	auto _padding = _o->padding;
12221	auto _stride_w = _o->stride_w;
12222	auto _stride_h = _o->stride_h;
12223	auto _depth_multiplier = _o->depth_multiplier;
12224	auto _fused_activation_function = _o->fused_activation_function;
12225	auto _dilation_w_factor = _o->dilation_w_factor;
12226	auto _dilation_h_factor = _o->dilation_h_factor;
12227	return tflite::CreateDepthwiseConv2DOptions(
12228	_fbb,
12229	_padding,
12230	_stride_w,
12231	_stride_h,
12232	_depth_multiplier,
12233	_fused_activation_function,
12234	_dilation_w_factor,
12235	_dilation_h_factor);
12236	}
12237
12238	inline ConcatEmbeddingsOptionsT ConcatEmbeddingsOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12239	auto _o = new ConcatEmbeddingsOptionsT ();
12240	UnPackTo(_o, _resolver);
12241	return _o;
12242	}
12243
12244	inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12245	(void)_o;
12246	(void)_resolver;
12247	{ auto _e = num_channels(); _o->num_channels = _e; }
12248	{ auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } }
12249	{ auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } }
12250	}
12251
12252	inline flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12253	return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
12254	}
12255
12256	inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12257	(void)_rehasher;
12258	(void)_o;
12259	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12260	auto _num_channels = _o->num_channels;
12261	auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : `0`;
12262	auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : `0`;
12263	return tflite::CreateConcatEmbeddingsOptions(
12264	_fbb,
12265	_num_channels,
12266	_num_columns_per_channel,
12267	_embedding_dim_per_channel);
12268	}
12269
12270	inline LSHProjectionOptionsT LSHProjectionOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12271	auto _o = new LSHProjectionOptionsT ();
12272	UnPackTo(_o, _resolver);
12273	return _o;
12274	}
12275
12276	inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12277	(void)_o;
12278	(void)_resolver;
12279	{ auto _e = type(); _o->type = _e; }
12280	}
12281
12282	inline flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12283	return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
12284	}
12285
12286	inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12287	(void)_rehasher;
12288	(void)_o;
12289	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12290	auto _type = _o->type;
12291	return tflite::CreateLSHProjectionOptions(
12292	_fbb,
12293	_type);
12294	}
12295
12296	inline SVDFOptionsT SVDFOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12297	auto _o = new SVDFOptionsT ();
12298	UnPackTo(_o, _resolver);
12299	return _o;
12300	}
12301
12302	inline void SVDFOptions::UnPackTo(SVDFOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12303	(void)_o;
12304	(void)_resolver;
12305	{ auto _e = rank(); _o->rank = _e; }
12306	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12307	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12308	}
12309
12310	inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12311	return CreateSVDFOptions(_fbb, _o, _rehasher);
12312	}
12313
12314	inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12315	(void)_rehasher;
12316	(void)_o;
12317	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SVDFOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12318	auto _rank = _o->rank;
12319	auto _fused_activation_function = _o->fused_activation_function;
12320	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12321	return tflite::CreateSVDFOptions(
12322	_fbb,
12323	_rank,
12324	_fused_activation_function,
12325	_asymmetric_quantize_inputs);
12326	}
12327
12328	inline RNNOptionsT RNNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12329	auto _o = new RNNOptionsT ();
12330	UnPackTo(_o, _resolver);
12331	return _o;
12332	}
12333
12334	inline void RNNOptions::UnPackTo(RNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12335	(void)_o;
12336	(void)_resolver;
12337	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12338	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12339	}
12340
12341	inline flatbuffers::Offset<RNNOptions> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12342	return CreateRNNOptions(_fbb, _o, _rehasher);
12343	}
12344
12345	inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12346	(void)_rehasher;
12347	(void)_o;
12348	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RNNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12349	auto _fused_activation_function = _o->fused_activation_function;
12350	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12351	return tflite::CreateRNNOptions(
12352	_fbb,
12353	_fused_activation_function,
12354	_asymmetric_quantize_inputs);
12355	}
12356
12357	inline SequenceRNNOptionsT SequenceRNNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12358	auto _o = new SequenceRNNOptionsT ();
12359	UnPackTo(_o, _resolver);
12360	return _o;
12361	}
12362
12363	inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12364	(void)_o;
12365	(void)_resolver;
12366	{ auto _e = time_major(); _o->time_major = _e; }
12367	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12368	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12369	}
12370
12371	inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12372	return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
12373	}
12374
12375	inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12376	(void)_rehasher;
12377	(void)_o;
12378	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12379	auto _time_major = _o->time_major;
12380	auto _fused_activation_function = _o->fused_activation_function;
12381	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12382	return tflite::CreateSequenceRNNOptions(
12383	_fbb,
12384	_time_major,
12385	_fused_activation_function,
12386	_asymmetric_quantize_inputs);
12387	}
12388
12389	inline BidirectionalSequenceRNNOptionsT BidirectionalSequenceRNNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12390	auto _o = new BidirectionalSequenceRNNOptionsT ();
12391	UnPackTo(_o, _resolver);
12392	return _o;
12393	}
12394
12395	inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12396	(void)_o;
12397	(void)_resolver;
12398	{ auto _e = time_major(); _o->time_major = _e; }
12399	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12400	{ auto _e = merge_outputs(); _o->merge_outputs = _e; }
12401	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12402	}
12403
12404	inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12405	return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
12406	}
12407
12408	inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12409	(void)_rehasher;
12410	(void)_o;
12411	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12412	auto _time_major = _o->time_major;
12413	auto _fused_activation_function = _o->fused_activation_function;
12414	auto _merge_outputs = _o->merge_outputs;
12415	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12416	return tflite::CreateBidirectionalSequenceRNNOptions(
12417	_fbb,
12418	_time_major,
12419	_fused_activation_function,
12420	_merge_outputs,
12421	_asymmetric_quantize_inputs);
12422	}
12423
12424	inline FullyConnectedOptionsT FullyConnectedOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12425	auto _o = new FullyConnectedOptionsT ();
12426	UnPackTo(_o, _resolver);
12427	return _o;
12428	}
12429
12430	inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12431	(void)_o;
12432	(void)_resolver;
12433	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12434	{ auto _e = weights_format(); _o->weights_format = _e; }
12435	{ auto _e = keep_num_dims(); _o->keep_num_dims = _e; }
12436	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12437	}
12438
12439	inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12440	return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
12441	}
12442
12443	inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12444	(void)_rehasher;
12445	(void)_o;
12446	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12447	auto _fused_activation_function = _o->fused_activation_function;
12448	auto _weights_format = _o->weights_format;
12449	auto _keep_num_dims = _o->keep_num_dims;
12450	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12451	return tflite::CreateFullyConnectedOptions(
12452	_fbb,
12453	_fused_activation_function,
12454	_weights_format,
12455	_keep_num_dims,
12456	_asymmetric_quantize_inputs);
12457	}
12458
12459	inline SoftmaxOptionsT SoftmaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12460	auto _o = new SoftmaxOptionsT ();
12461	UnPackTo(_o, _resolver);
12462	return _o;
12463	}
12464
12465	inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12466	(void)_o;
12467	(void)_resolver;
12468	{ auto _e = beta(); _o->beta = _e; }
12469	}
12470
12471	inline flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12472	return CreateSoftmaxOptions(_fbb, _o, _rehasher);
12473	}
12474
12475	inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12476	(void)_rehasher;
12477	(void)_o;
12478	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12479	auto _beta = _o->beta;
12480	return tflite::CreateSoftmaxOptions(
12481	_fbb,
12482	_beta);
12483	}
12484
12485	inline ConcatenationOptionsT ConcatenationOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12486	auto _o = new ConcatenationOptionsT ();
12487	UnPackTo(_o, _resolver);
12488	return _o;
12489	}
12490
12491	inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12492	(void)_o;
12493	(void)_resolver;
12494	{ auto _e = axis(); _o->axis = _e; }
12495	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12496	}
12497
12498	inline flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12499	return CreateConcatenationOptions(_fbb, _o, _rehasher);
12500	}
12501
12502	inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12503	(void)_rehasher;
12504	(void)_o;
12505	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12506	auto _axis = _o->axis;
12507	auto _fused_activation_function = _o->fused_activation_function;
12508	return tflite::CreateConcatenationOptions(
12509	_fbb,
12510	_axis,
12511	_fused_activation_function);
12512	}
12513
12514	inline AddOptionsT AddOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12515	auto _o = new AddOptionsT ();
12516	UnPackTo(_o, _resolver);
12517	return _o;
12518	}
12519
12520	inline void AddOptions::UnPackTo(AddOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12521	(void)_o;
12522	(void)_resolver;
12523	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12524	{ auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
12525	}
12526
12527	inline flatbuffers::Offset<AddOptions> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12528	return CreateAddOptions(_fbb, _o, _rehasher);
12529	}
12530
12531	inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12532	(void)_rehasher;
12533	(void)_o;
12534	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AddOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12535	auto _fused_activation_function = _o->fused_activation_function;
12536	auto _pot_scale_int16 = _o->pot_scale_int16;
12537	return tflite::CreateAddOptions(
12538	_fbb,
12539	_fused_activation_function,
12540	_pot_scale_int16);
12541	}
12542
12543	inline MulOptionsT MulOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12544	auto _o = new MulOptionsT ();
12545	UnPackTo(_o, _resolver);
12546	return _o;
12547	}
12548
12549	inline void MulOptions::UnPackTo(MulOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12550	(void)_o;
12551	(void)_resolver;
12552	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12553	}
12554
12555	inline flatbuffers::Offset<MulOptions> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12556	return CreateMulOptions(_fbb, _o, _rehasher);
12557	}
12558
12559	inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12560	(void)_rehasher;
12561	(void)_o;
12562	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MulOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12563	auto _fused_activation_function = _o->fused_activation_function;
12564	return tflite::CreateMulOptions(
12565	_fbb,
12566	_fused_activation_function);
12567	}
12568
12569	inline L2NormOptionsT L2NormOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12570	auto _o = new L2NormOptionsT ();
12571	UnPackTo(_o, _resolver);
12572	return _o;
12573	}
12574
12575	inline void L2NormOptions::UnPackTo(L2NormOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12576	(void)_o;
12577	(void)_resolver;
12578	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12579	}
12580
12581	inline flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12582	return CreateL2NormOptions(_fbb, _o, _rehasher);
12583	}
12584
12585	inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12586	(void)_rehasher;
12587	(void)_o;
12588	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* L2NormOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12589	auto _fused_activation_function = _o->fused_activation_function;
12590	return tflite::CreateL2NormOptions(
12591	_fbb,
12592	_fused_activation_function);
12593	}
12594
12595	inline LocalResponseNormalizationOptionsT LocalResponseNormalizationOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12596	auto _o = new LocalResponseNormalizationOptionsT ();
12597	UnPackTo(_o, _resolver);
12598	return _o;
12599	}
12600
12601	inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12602	(void)_o;
12603	(void)_resolver;
12604	{ auto _e = radius(); _o->radius = _e; }
12605	{ auto _e = bias(); _o->bias = _e; }
12606	{ auto _e = alpha(); _o->alpha = _e; }
12607	{ auto _e = beta(); _o->beta = _e; }
12608	}
12609
12610	inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12611	return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
12612	}
12613
12614	inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12615	(void)_rehasher;
12616	(void)_o;
12617	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12618	auto _radius = _o->radius;
12619	auto _bias = _o->bias;
12620	auto _alpha = _o->alpha;
12621	auto _beta = _o->beta;
12622	return tflite::CreateLocalResponseNormalizationOptions(
12623	_fbb,
12624	_radius,
12625	_bias,
12626	_alpha,
12627	_beta);
12628	}
12629
12630	inline LSTMOptionsT LSTMOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12631	auto _o = new LSTMOptionsT ();
12632	UnPackTo(_o, _resolver);
12633	return _o;
12634	}
12635
12636	inline void LSTMOptions::UnPackTo(LSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12637	(void)_o;
12638	(void)_resolver;
12639	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12640	{ auto _e = cell_clip(); _o->cell_clip = _e; }
12641	{ auto _e = proj_clip(); _o->proj_clip = _e; }
12642	{ auto _e = kernel_type(); _o->kernel_type = _e; }
12643	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12644	}
12645
12646	inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12647	return CreateLSTMOptions(_fbb, _o, _rehasher);
12648	}
12649
12650	inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12651	(void)_rehasher;
12652	(void)_o;
12653	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LSTMOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12654	auto _fused_activation_function = _o->fused_activation_function;
12655	auto _cell_clip = _o->cell_clip;
12656	auto _proj_clip = _o->proj_clip;
12657	auto _kernel_type = _o->kernel_type;
12658	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12659	return tflite::CreateLSTMOptions(
12660	_fbb,
12661	_fused_activation_function,
12662	_cell_clip,
12663	_proj_clip,
12664	_kernel_type,
12665	_asymmetric_quantize_inputs);
12666	}
12667
12668	inline UnidirectionalSequenceLSTMOptionsT UnidirectionalSequenceLSTMOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12669	auto _o = new UnidirectionalSequenceLSTMOptionsT ();
12670	UnPackTo(_o, _resolver);
12671	return _o;
12672	}
12673
12674	inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12675	(void)_o;
12676	(void)_resolver;
12677	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12678	{ auto _e = cell_clip(); _o->cell_clip = _e; }
12679	{ auto _e = proj_clip(); _o->proj_clip = _e; }
12680	{ auto _e = time_major(); _o->time_major = _e; }
12681	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12682	}
12683
12684	inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12685	return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
12686	}
12687
12688	inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12689	(void)_rehasher;
12690	(void)_o;
12691	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12692	auto _fused_activation_function = _o->fused_activation_function;
12693	auto _cell_clip = _o->cell_clip;
12694	auto _proj_clip = _o->proj_clip;
12695	auto _time_major = _o->time_major;
12696	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12697	return tflite::CreateUnidirectionalSequenceLSTMOptions(
12698	_fbb,
12699	_fused_activation_function,
12700	_cell_clip,
12701	_proj_clip,
12702	_time_major,
12703	_asymmetric_quantize_inputs);
12704	}
12705
12706	inline BidirectionalSequenceLSTMOptionsT BidirectionalSequenceLSTMOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12707	auto _o = new BidirectionalSequenceLSTMOptionsT ();
12708	UnPackTo(_o, _resolver);
12709	return _o;
12710	}
12711
12712	inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12713	(void)_o;
12714	(void)_resolver;
12715	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
12716	{ auto _e = cell_clip(); _o->cell_clip = _e; }
12717	{ auto _e = proj_clip(); _o->proj_clip = _e; }
12718	{ auto _e = merge_outputs(); _o->merge_outputs = _e; }
12719	{ auto _e = time_major(); _o->time_major = _e; }
12720	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
12721	}
12722
12723	inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12724	return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
12725	}
12726
12727	inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12728	(void)_rehasher;
12729	(void)_o;
12730	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12731	auto _fused_activation_function = _o->fused_activation_function;
12732	auto _cell_clip = _o->cell_clip;
12733	auto _proj_clip = _o->proj_clip;
12734	auto _merge_outputs = _o->merge_outputs;
12735	auto _time_major = _o->time_major;
12736	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
12737	return tflite::CreateBidirectionalSequenceLSTMOptions(
12738	_fbb,
12739	_fused_activation_function,
12740	_cell_clip,
12741	_proj_clip,
12742	_merge_outputs,
12743	_time_major,
12744	_asymmetric_quantize_inputs);
12745	}
12746
12747	inline ResizeBilinearOptionsT ResizeBilinearOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12748	auto _o = new ResizeBilinearOptionsT ();
12749	UnPackTo(_o, _resolver);
12750	return _o;
12751	}
12752
12753	inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12754	(void)_o;
12755	(void)_resolver;
12756	{ auto _e = align_corners(); _o->align_corners = _e; }
12757	{ auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
12758	}
12759
12760	inline flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12761	return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
12762	}
12763
12764	inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12765	(void)_rehasher;
12766	(void)_o;
12767	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12768	auto _align_corners = _o->align_corners;
12769	auto _half_pixel_centers = _o->half_pixel_centers;
12770	return tflite::CreateResizeBilinearOptions(
12771	_fbb,
12772	_align_corners,
12773	_half_pixel_centers);
12774	}
12775
12776	inline ResizeNearestNeighborOptionsT ResizeNearestNeighborOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12777	auto _o = new ResizeNearestNeighborOptionsT ();
12778	UnPackTo(_o, _resolver);
12779	return _o;
12780	}
12781
12782	inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12783	(void)_o;
12784	(void)_resolver;
12785	{ auto _e = align_corners(); _o->align_corners = _e; }
12786	{ auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
12787	}
12788
12789	inline flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12790	return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
12791	}
12792
12793	inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12794	(void)_rehasher;
12795	(void)_o;
12796	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12797	auto _align_corners = _o->align_corners;
12798	auto _half_pixel_centers = _o->half_pixel_centers;
12799	return tflite::CreateResizeNearestNeighborOptions(
12800	_fbb,
12801	_align_corners,
12802	_half_pixel_centers);
12803	}
12804
12805	inline CallOptionsT CallOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12806	auto _o = new CallOptionsT ();
12807	UnPackTo(_o, _resolver);
12808	return _o;
12809	}
12810
12811	inline void CallOptions::UnPackTo(CallOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12812	(void)_o;
12813	(void)_resolver;
12814	{ auto _e = subgraph(); _o->subgraph = _e; }
12815	}
12816
12817	inline flatbuffers::Offset<CallOptions> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12818	return CreateCallOptions(_fbb, _o, _rehasher);
12819	}
12820
12821	inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12822	(void)_rehasher;
12823	(void)_o;
12824	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CallOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12825	auto _subgraph = _o->subgraph;
12826	return tflite::CreateCallOptions(
12827	_fbb,
12828	_subgraph);
12829	}
12830
12831	inline PadOptionsT PadOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12832	auto _o = new PadOptionsT ();
12833	UnPackTo(_o, _resolver);
12834	return _o;
12835	}
12836
12837	inline void PadOptions::UnPackTo(PadOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12838	(void)_o;
12839	(void)_resolver;
12840	}
12841
12842	inline flatbuffers::Offset<PadOptions> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12843	return CreatePadOptions(_fbb, _o, _rehasher);
12844	}
12845
12846	inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12847	(void)_rehasher;
12848	(void)_o;
12849	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PadOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12850	return tflite::CreatePadOptions(
12851	_fbb);
12852	}
12853
12854	inline PadV2OptionsT PadV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12855	auto _o = new PadV2OptionsT ();
12856	UnPackTo(_o, _resolver);
12857	return _o;
12858	}
12859
12860	inline void PadV2Options::UnPackTo(PadV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12861	(void)_o;
12862	(void)_resolver;
12863	}
12864
12865	inline flatbuffers::Offset<PadV2Options> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12866	return CreatePadV2Options(_fbb, _o, _rehasher);
12867	}
12868
12869	inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12870	(void)_rehasher;
12871	(void)_o;
12872	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PadV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12873	return tflite::CreatePadV2Options(
12874	_fbb);
12875	}
12876
12877	inline ReshapeOptionsT ReshapeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12878	auto _o = new ReshapeOptionsT ();
12879	UnPackTo(_o, _resolver);
12880	return _o;
12881	}
12882
12883	inline void ReshapeOptions::UnPackTo(ReshapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12884	(void)_o;
12885	(void)_resolver;
12886	{ auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } }
12887	}
12888
12889	inline flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12890	return CreateReshapeOptions(_fbb, _o, _rehasher);
12891	}
12892
12893	inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12894	(void)_rehasher;
12895	(void)_o;
12896	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12897	auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : `0`;
12898	return tflite::CreateReshapeOptions(
12899	_fbb,
12900	_new_shape);
12901	}
12902
12903	inline SpaceToBatchNDOptionsT SpaceToBatchNDOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12904	auto _o = new SpaceToBatchNDOptionsT ();
12905	UnPackTo(_o, _resolver);
12906	return _o;
12907	}
12908
12909	inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12910	(void)_o;
12911	(void)_resolver;
12912	}
12913
12914	inline flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12915	return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
12916	}
12917
12918	inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12919	(void)_rehasher;
12920	(void)_o;
12921	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12922	return tflite::CreateSpaceToBatchNDOptions(
12923	_fbb);
12924	}
12925
12926	inline BatchToSpaceNDOptionsT BatchToSpaceNDOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12927	auto _o = new BatchToSpaceNDOptionsT ();
12928	UnPackTo(_o, _resolver);
12929	return _o;
12930	}
12931
12932	inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12933	(void)_o;
12934	(void)_resolver;
12935	}
12936
12937	inline flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12938	return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
12939	}
12940
12941	inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12942	(void)_rehasher;
12943	(void)_o;
12944	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12945	return tflite::CreateBatchToSpaceNDOptions(
12946	_fbb);
12947	}
12948
12949	inline SkipGramOptionsT SkipGramOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12950	auto _o = new SkipGramOptionsT ();
12951	UnPackTo(_o, _resolver);
12952	return _o;
12953	}
12954
12955	inline void SkipGramOptions::UnPackTo(SkipGramOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12956	(void)_o;
12957	(void)_resolver;
12958	{ auto _e = ngram_size(); _o->ngram_size = _e; }
12959	{ auto _e = max_skip_size(); _o->max_skip_size = _e; }
12960	{ auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }
12961	}
12962
12963	inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12964	return CreateSkipGramOptions(_fbb, _o, _rehasher);
12965	}
12966
12967	inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12968	(void)_rehasher;
12969	(void)_o;
12970	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
12971	auto _ngram_size = _o->ngram_size;
12972	auto _max_skip_size = _o->max_skip_size;
12973	auto _include_all_ngrams = _o->include_all_ngrams;
12974	return tflite::CreateSkipGramOptions(
12975	_fbb,
12976	_ngram_size,
12977	_max_skip_size,
12978	_include_all_ngrams);
12979	}
12980
12981	inline SpaceToDepthOptionsT SpaceToDepthOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
12982	auto _o = new SpaceToDepthOptionsT ();
12983	UnPackTo(_o, _resolver);
12984	return _o;
12985	}
12986
12987	inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
12988	(void)_o;
12989	(void)_resolver;
12990	{ auto _e = block_size(); _o->block_size = _e; }
12991	}
12992
12993	inline flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
12994	return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
12995	}
12996
12997	inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
12998	(void)_rehasher;
12999	(void)_o;
13000	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13001	auto _block_size = _o->block_size;
13002	return tflite::CreateSpaceToDepthOptions(
13003	_fbb,
13004	_block_size);
13005	}
13006
13007	inline DepthToSpaceOptionsT DepthToSpaceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13008	auto _o = new DepthToSpaceOptionsT ();
13009	UnPackTo(_o, _resolver);
13010	return _o;
13011	}
13012
13013	inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13014	(void)_o;
13015	(void)_resolver;
13016	{ auto _e = block_size(); _o->block_size = _e; }
13017	}
13018
13019	inline flatbuffers::Offset<DepthToSpaceOptions> DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13020	return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
13021	}
13022
13023	inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13024	(void)_rehasher;
13025	(void)_o;
13026	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DepthToSpaceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13027	auto _block_size = _o->block_size;
13028	return tflite::CreateDepthToSpaceOptions(
13029	_fbb,
13030	_block_size);
13031	}
13032
13033	inline SubOptionsT SubOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13034	auto _o = new SubOptionsT ();
13035	UnPackTo(_o, _resolver);
13036	return _o;
13037	}
13038
13039	inline void SubOptions::UnPackTo(SubOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13040	(void)_o;
13041	(void)_resolver;
13042	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13043	{ auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
13044	}
13045
13046	inline flatbuffers::Offset<SubOptions> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13047	return CreateSubOptions(_fbb, _o, _rehasher);
13048	}
13049
13050	inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13051	(void)_rehasher;
13052	(void)_o;
13053	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SubOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13054	auto _fused_activation_function = _o->fused_activation_function;
13055	auto _pot_scale_int16 = _o->pot_scale_int16;
13056	return tflite::CreateSubOptions(
13057	_fbb,
13058	_fused_activation_function,
13059	_pot_scale_int16);
13060	}
13061
13062	inline DivOptionsT DivOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13063	auto _o = new DivOptionsT ();
13064	UnPackTo(_o, _resolver);
13065	return _o;
13066	}
13067
13068	inline void DivOptions::UnPackTo(DivOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13069	(void)_o;
13070	(void)_resolver;
13071	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13072	}
13073
13074	inline flatbuffers::Offset<DivOptions> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13075	return CreateDivOptions(_fbb, _o, _rehasher);
13076	}
13077
13078	inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13079	(void)_rehasher;
13080	(void)_o;
13081	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DivOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13082	auto _fused_activation_function = _o->fused_activation_function;
13083	return tflite::CreateDivOptions(
13084	_fbb,
13085	_fused_activation_function);
13086	}
13087
13088	inline TopKV2OptionsT TopKV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13089	auto _o = new TopKV2OptionsT ();
13090	UnPackTo(_o, _resolver);
13091	return _o;
13092	}
13093
13094	inline void TopKV2Options::UnPackTo(TopKV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13095	(void)_o;
13096	(void)_resolver;
13097	}
13098
13099	inline flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13100	return CreateTopKV2Options(_fbb, _o, _rehasher);
13101	}
13102
13103	inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13104	(void)_rehasher;
13105	(void)_o;
13106	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13107	return tflite::CreateTopKV2Options(
13108	_fbb);
13109	}
13110
13111	inline EmbeddingLookupSparseOptionsT EmbeddingLookupSparseOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13112	auto _o = new EmbeddingLookupSparseOptionsT ();
13113	UnPackTo(_o, _resolver);
13114	return _o;
13115	}
13116
13117	inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13118	(void)_o;
13119	(void)_resolver;
13120	{ auto _e = combiner(); _o->combiner = _e; }
13121	}
13122
13123	inline flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13124	return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
13125	}
13126
13127	inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13128	(void)_rehasher;
13129	(void)_o;
13130	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13131	auto _combiner = _o->combiner;
13132	return tflite::CreateEmbeddingLookupSparseOptions(
13133	_fbb,
13134	_combiner);
13135	}
13136
13137	inline GatherOptionsT GatherOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13138	auto _o = new GatherOptionsT ();
13139	UnPackTo(_o, _resolver);
13140	return _o;
13141	}
13142
13143	inline void GatherOptions::UnPackTo(GatherOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13144	(void)_o;
13145	(void)_resolver;
13146	{ auto _e = axis(); _o->axis = _e; }
13147	{ auto _e = batch_dims(); _o->batch_dims = _e; }
13148	}
13149
13150	inline flatbuffers::Offset<GatherOptions> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13151	return CreateGatherOptions(_fbb, _o, _rehasher);
13152	}
13153
13154	inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13155	(void)_rehasher;
13156	(void)_o;
13157	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GatherOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13158	auto _axis = _o->axis;
13159	auto _batch_dims = _o->batch_dims;
13160	return tflite::CreateGatherOptions(
13161	_fbb,
13162	_axis,
13163	_batch_dims);
13164	}
13165
13166	inline TransposeOptionsT TransposeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13167	auto _o = new TransposeOptionsT ();
13168	UnPackTo(_o, _resolver);
13169	return _o;
13170	}
13171
13172	inline void TransposeOptions::UnPackTo(TransposeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13173	(void)_o;
13174	(void)_resolver;
13175	}
13176
13177	inline flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13178	return CreateTransposeOptions(_fbb, _o, _rehasher);
13179	}
13180
13181	inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13182	(void)_rehasher;
13183	(void)_o;
13184	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TransposeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13185	return tflite::CreateTransposeOptions(
13186	_fbb);
13187	}
13188
13189	inline ExpOptionsT ExpOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13190	auto _o = new ExpOptionsT ();
13191	UnPackTo(_o, _resolver);
13192	return _o;
13193	}
13194
13195	inline void ExpOptions::UnPackTo(ExpOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13196	(void)_o;
13197	(void)_resolver;
13198	}
13199
13200	inline flatbuffers::Offset<ExpOptions> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13201	return CreateExpOptions(_fbb, _o, _rehasher);
13202	}
13203
13204	inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13205	(void)_rehasher;
13206	(void)_o;
13207	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ExpOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13208	return tflite::CreateExpOptions(
13209	_fbb);
13210	}
13211
13212	inline CosOptionsT CosOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13213	auto _o = new CosOptionsT ();
13214	UnPackTo(_o, _resolver);
13215	return _o;
13216	}
13217
13218	inline void CosOptions::UnPackTo(CosOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13219	(void)_o;
13220	(void)_resolver;
13221	}
13222
13223	inline flatbuffers::Offset<CosOptions> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13224	return CreateCosOptions(_fbb, _o, _rehasher);
13225	}
13226
13227	inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13228	(void)_rehasher;
13229	(void)_o;
13230	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CosOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13231	return tflite::CreateCosOptions(
13232	_fbb);
13233	}
13234
13235	inline ReducerOptionsT ReducerOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13236	auto _o = new ReducerOptionsT ();
13237	UnPackTo(_o, _resolver);
13238	return _o;
13239	}
13240
13241	inline void ReducerOptions::UnPackTo(ReducerOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13242	(void)_o;
13243	(void)_resolver;
13244	{ auto _e = keep_dims(); _o->keep_dims = _e; }
13245	}
13246
13247	inline flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13248	return CreateReducerOptions(_fbb, _o, _rehasher);
13249	}
13250
13251	inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13252	(void)_rehasher;
13253	(void)_o;
13254	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReducerOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13255	auto _keep_dims = _o->keep_dims;
13256	return tflite::CreateReducerOptions(
13257	_fbb,
13258	_keep_dims);
13259	}
13260
13261	inline SqueezeOptionsT SqueezeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13262	auto _o = new SqueezeOptionsT ();
13263	UnPackTo(_o, _resolver);
13264	return _o;
13265	}
13266
13267	inline void SqueezeOptions::UnPackTo(SqueezeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13268	(void)_o;
13269	(void)_resolver;
13270	{ auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } }
13271	}
13272
13273	inline flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13274	return CreateSqueezeOptions(_fbb, _o, _rehasher);
13275	}
13276
13277	inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13278	(void)_rehasher;
13279	(void)_o;
13280	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13281	auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : `0`;
13282	return tflite::CreateSqueezeOptions(
13283	_fbb,
13284	_squeeze_dims);
13285	}
13286
13287	inline SplitOptionsT SplitOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13288	auto _o = new SplitOptionsT ();
13289	UnPackTo(_o, _resolver);
13290	return _o;
13291	}
13292
13293	inline void SplitOptions::UnPackTo(SplitOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13294	(void)_o;
13295	(void)_resolver;
13296	{ auto _e = num_splits(); _o->num_splits = _e; }
13297	}
13298
13299	inline flatbuffers::Offset<SplitOptions> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13300	return CreateSplitOptions(_fbb, _o, _rehasher);
13301	}
13302
13303	inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13304	(void)_rehasher;
13305	(void)_o;
13306	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SplitOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13307	auto _num_splits = _o->num_splits;
13308	return tflite::CreateSplitOptions(
13309	_fbb,
13310	_num_splits);
13311	}
13312
13313	inline SplitVOptionsT SplitVOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13314	auto _o = new SplitVOptionsT ();
13315	UnPackTo(_o, _resolver);
13316	return _o;
13317	}
13318
13319	inline void SplitVOptions::UnPackTo(SplitVOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13320	(void)_o;
13321	(void)_resolver;
13322	{ auto _e = num_splits(); _o->num_splits = _e; }
13323	}
13324
13325	inline flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13326	return CreateSplitVOptions(_fbb, _o, _rehasher);
13327	}
13328
13329	inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13330	(void)_rehasher;
13331	(void)_o;
13332	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SplitVOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13333	auto _num_splits = _o->num_splits;
13334	return tflite::CreateSplitVOptions(
13335	_fbb,
13336	_num_splits);
13337	}
13338
13339	inline StridedSliceOptionsT StridedSliceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13340	auto _o = new StridedSliceOptionsT ();
13341	UnPackTo(_o, _resolver);
13342	return _o;
13343	}
13344
13345	inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13346	(void)_o;
13347	(void)_resolver;
13348	{ auto _e = begin_mask(); _o->begin_mask = _e; }
13349	{ auto _e = end_mask(); _o->end_mask = _e; }
13350	{ auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; }
13351	{ auto _e = new_axis_mask(); _o->new_axis_mask = _e; }
13352	{ auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _e; }
13353	}
13354
13355	inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13356	return CreateStridedSliceOptions(_fbb, _o, _rehasher);
13357	}
13358
13359	inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13360	(void)_rehasher;
13361	(void)_o;
13362	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13363	auto _begin_mask = _o->begin_mask;
13364	auto _end_mask = _o->end_mask;
13365	auto _ellipsis_mask = _o->ellipsis_mask;
13366	auto _new_axis_mask = _o->new_axis_mask;
13367	auto _shrink_axis_mask = _o->shrink_axis_mask;
13368	return tflite::CreateStridedSliceOptions(
13369	_fbb,
13370	_begin_mask,
13371	_end_mask,
13372	_ellipsis_mask,
13373	_new_axis_mask,
13374	_shrink_axis_mask);
13375	}
13376
13377	inline LogSoftmaxOptionsT LogSoftmaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13378	auto _o = new LogSoftmaxOptionsT ();
13379	UnPackTo(_o, _resolver);
13380	return _o;
13381	}
13382
13383	inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13384	(void)_o;
13385	(void)_resolver;
13386	}
13387
13388	inline flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13389	return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
13390	}
13391
13392	inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13393	(void)_rehasher;
13394	(void)_o;
13395	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13396	return tflite::CreateLogSoftmaxOptions(
13397	_fbb);
13398	}
13399
13400	inline CastOptionsT CastOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13401	auto _o = new CastOptionsT ();
13402	UnPackTo(_o, _resolver);
13403	return _o;
13404	}
13405
13406	inline void CastOptions::UnPackTo(CastOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13407	(void)_o;
13408	(void)_resolver;
13409	{ auto _e = in_data_type(); _o->in_data_type = _e; }
13410	{ auto _e = out_data_type(); _o->out_data_type = _e; }
13411	}
13412
13413	inline flatbuffers::Offset<CastOptions> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13414	return CreateCastOptions(_fbb, _o, _rehasher);
13415	}
13416
13417	inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13418	(void)_rehasher;
13419	(void)_o;
13420	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CastOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13421	auto _in_data_type = _o->in_data_type;
13422	auto _out_data_type = _o->out_data_type;
13423	return tflite::CreateCastOptions(
13424	_fbb,
13425	_in_data_type,
13426	_out_data_type);
13427	}
13428
13429	inline DequantizeOptionsT DequantizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13430	auto _o = new DequantizeOptionsT ();
13431	UnPackTo(_o, _resolver);
13432	return _o;
13433	}
13434
13435	inline void DequantizeOptions::UnPackTo(DequantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13436	(void)_o;
13437	(void)_resolver;
13438	}
13439
13440	inline flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13441	return CreateDequantizeOptions(_fbb, _o, _rehasher);
13442	}
13443
13444	inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13445	(void)_rehasher;
13446	(void)_o;
13447	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13448	return tflite::CreateDequantizeOptions(
13449	_fbb);
13450	}
13451
13452	inline MaximumMinimumOptionsT MaximumMinimumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13453	auto _o = new MaximumMinimumOptionsT ();
13454	UnPackTo(_o, _resolver);
13455	return _o;
13456	}
13457
13458	inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13459	(void)_o;
13460	(void)_resolver;
13461	}
13462
13463	inline flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13464	return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
13465	}
13466
13467	inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13468	(void)_rehasher;
13469	(void)_o;
13470	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13471	return tflite::CreateMaximumMinimumOptions(
13472	_fbb);
13473	}
13474
13475	inline TileOptionsT TileOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13476	auto _o = new TileOptionsT ();
13477	UnPackTo(_o, _resolver);
13478	return _o;
13479	}
13480
13481	inline void TileOptions::UnPackTo(TileOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13482	(void)_o;
13483	(void)_resolver;
13484	}
13485
13486	inline flatbuffers::Offset<TileOptions> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13487	return CreateTileOptions(_fbb, _o, _rehasher);
13488	}
13489
13490	inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13491	(void)_rehasher;
13492	(void)_o;
13493	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TileOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13494	return tflite::CreateTileOptions(
13495	_fbb);
13496	}
13497
13498	inline ArgMaxOptionsT ArgMaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13499	auto _o = new ArgMaxOptionsT ();
13500	UnPackTo(_o, _resolver);
13501	return _o;
13502	}
13503
13504	inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13505	(void)_o;
13506	(void)_resolver;
13507	{ auto _e = output_type(); _o->output_type = _e; }
13508	}
13509
13510	inline flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13511	return CreateArgMaxOptions(_fbb, _o, _rehasher);
13512	}
13513
13514	inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13515	(void)_rehasher;
13516	(void)_o;
13517	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13518	auto _output_type = _o->output_type;
13519	return tflite::CreateArgMaxOptions(
13520	_fbb,
13521	_output_type);
13522	}
13523
13524	inline ArgMinOptionsT ArgMinOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13525	auto _o = new ArgMinOptionsT ();
13526	UnPackTo(_o, _resolver);
13527	return _o;
13528	}
13529
13530	inline void ArgMinOptions::UnPackTo(ArgMinOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13531	(void)_o;
13532	(void)_resolver;
13533	{ auto _e = output_type(); _o->output_type = _e; }
13534	}
13535
13536	inline flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13537	return CreateArgMinOptions(_fbb, _o, _rehasher);
13538	}
13539
13540	inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13541	(void)_rehasher;
13542	(void)_o;
13543	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13544	auto _output_type = _o->output_type;
13545	return tflite::CreateArgMinOptions(
13546	_fbb,
13547	_output_type);
13548	}
13549
13550	inline GreaterOptionsT GreaterOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13551	auto _o = new GreaterOptionsT ();
13552	UnPackTo(_o, _resolver);
13553	return _o;
13554	}
13555
13556	inline void GreaterOptions::UnPackTo(GreaterOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13557	(void)_o;
13558	(void)_resolver;
13559	}
13560
13561	inline flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13562	return CreateGreaterOptions(_fbb, _o, _rehasher);
13563	}
13564
13565	inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13566	(void)_rehasher;
13567	(void)_o;
13568	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GreaterOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13569	return tflite::CreateGreaterOptions(
13570	_fbb);
13571	}
13572
13573	inline GreaterEqualOptionsT GreaterEqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13574	auto _o = new GreaterEqualOptionsT ();
13575	UnPackTo(_o, _resolver);
13576	return _o;
13577	}
13578
13579	inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13580	(void)_o;
13581	(void)_resolver;
13582	}
13583
13584	inline flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13585	return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
13586	}
13587
13588	inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13589	(void)_rehasher;
13590	(void)_o;
13591	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13592	return tflite::CreateGreaterEqualOptions(
13593	_fbb);
13594	}
13595
13596	inline LessOptionsT LessOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13597	auto _o = new LessOptionsT ();
13598	UnPackTo(_o, _resolver);
13599	return _o;
13600	}
13601
13602	inline void LessOptions::UnPackTo(LessOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13603	(void)_o;
13604	(void)_resolver;
13605	}
13606
13607	inline flatbuffers::Offset<LessOptions> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13608	return CreateLessOptions(_fbb, _o, _rehasher);
13609	}
13610
13611	inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13612	(void)_rehasher;
13613	(void)_o;
13614	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LessOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13615	return tflite::CreateLessOptions(
13616	_fbb);
13617	}
13618
13619	inline LessEqualOptionsT LessEqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13620	auto _o = new LessEqualOptionsT ();
13621	UnPackTo(_o, _resolver);
13622	return _o;
13623	}
13624
13625	inline void LessEqualOptions::UnPackTo(LessEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13626	(void)_o;
13627	(void)_resolver;
13628	}
13629
13630	inline flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13631	return CreateLessEqualOptions(_fbb, _o, _rehasher);
13632	}
13633
13634	inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13635	(void)_rehasher;
13636	(void)_o;
13637	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13638	return tflite::CreateLessEqualOptions(
13639	_fbb);
13640	}
13641
13642	inline NegOptionsT NegOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13643	auto _o = new NegOptionsT ();
13644	UnPackTo(_o, _resolver);
13645	return _o;
13646	}
13647
13648	inline void NegOptions::UnPackTo(NegOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13649	(void)_o;
13650	(void)_resolver;
13651	}
13652
13653	inline flatbuffers::Offset<NegOptions> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13654	return CreateNegOptions(_fbb, _o, _rehasher);
13655	}
13656
13657	inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13658	(void)_rehasher;
13659	(void)_o;
13660	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NegOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13661	return tflite::CreateNegOptions(
13662	_fbb);
13663	}
13664
13665	inline SelectOptionsT SelectOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13666	auto _o = new SelectOptionsT ();
13667	UnPackTo(_o, _resolver);
13668	return _o;
13669	}
13670
13671	inline void SelectOptions::UnPackTo(SelectOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13672	(void)_o;
13673	(void)_resolver;
13674	}
13675
13676	inline flatbuffers::Offset<SelectOptions> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13677	return CreateSelectOptions(_fbb, _o, _rehasher);
13678	}
13679
13680	inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13681	(void)_rehasher;
13682	(void)_o;
13683	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SelectOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13684	return tflite::CreateSelectOptions(
13685	_fbb);
13686	}
13687
13688	inline SliceOptionsT SliceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13689	auto _o = new SliceOptionsT ();
13690	UnPackTo(_o, _resolver);
13691	return _o;
13692	}
13693
13694	inline void SliceOptions::UnPackTo(SliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13695	(void)_o;
13696	(void)_resolver;
13697	}
13698
13699	inline flatbuffers::Offset<SliceOptions> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13700	return CreateSliceOptions(_fbb, _o, _rehasher);
13701	}
13702
13703	inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13704	(void)_rehasher;
13705	(void)_o;
13706	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SliceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13707	return tflite::CreateSliceOptions(
13708	_fbb);
13709	}
13710
13711	inline TransposeConvOptionsT TransposeConvOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13712	auto _o = new TransposeConvOptionsT ();
13713	UnPackTo(_o, _resolver);
13714	return _o;
13715	}
13716
13717	inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13718	(void)_o;
13719	(void)_resolver;
13720	{ auto _e = padding(); _o->padding = _e; }
13721	{ auto _e = stride_w(); _o->stride_w = _e; }
13722	{ auto _e = stride_h(); _o->stride_h = _e; }
13723	}
13724
13725	inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13726	return CreateTransposeConvOptions(_fbb, _o, _rehasher);
13727	}
13728
13729	inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13730	(void)_rehasher;
13731	(void)_o;
13732	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13733	auto _padding = _o->padding;
13734	auto _stride_w = _o->stride_w;
13735	auto _stride_h = _o->stride_h;
13736	return tflite::CreateTransposeConvOptions(
13737	_fbb,
13738	_padding,
13739	_stride_w,
13740	_stride_h);
13741	}
13742
13743	inline ExpandDimsOptionsT ExpandDimsOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13744	auto _o = new ExpandDimsOptionsT ();
13745	UnPackTo(_o, _resolver);
13746	return _o;
13747	}
13748
13749	inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13750	(void)_o;
13751	(void)_resolver;
13752	}
13753
13754	inline flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13755	return CreateExpandDimsOptions(_fbb, _o, _rehasher);
13756	}
13757
13758	inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13759	(void)_rehasher;
13760	(void)_o;
13761	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13762	return tflite::CreateExpandDimsOptions(
13763	_fbb);
13764	}
13765
13766	inline SparseToDenseOptionsT SparseToDenseOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13767	auto _o = new SparseToDenseOptionsT ();
13768	UnPackTo(_o, _resolver);
13769	return _o;
13770	}
13771
13772	inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13773	(void)_o;
13774	(void)_resolver;
13775	{ auto _e = validate_indices(); _o->validate_indices = _e; }
13776	}
13777
13778	inline flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13779	return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
13780	}
13781
13782	inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13783	(void)_rehasher;
13784	(void)_o;
13785	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13786	auto _validate_indices = _o->validate_indices;
13787	return tflite::CreateSparseToDenseOptions(
13788	_fbb,
13789	_validate_indices);
13790	}
13791
13792	inline EqualOptionsT EqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13793	auto _o = new EqualOptionsT ();
13794	UnPackTo(_o, _resolver);
13795	return _o;
13796	}
13797
13798	inline void EqualOptions::UnPackTo(EqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13799	(void)_o;
13800	(void)_resolver;
13801	}
13802
13803	inline flatbuffers::Offset<EqualOptions> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13804	return CreateEqualOptions(_fbb, _o, _rehasher);
13805	}
13806
13807	inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13808	(void)_rehasher;
13809	(void)_o;
13810	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* EqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13811	return tflite::CreateEqualOptions(
13812	_fbb);
13813	}
13814
13815	inline NotEqualOptionsT NotEqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13816	auto _o = new NotEqualOptionsT ();
13817	UnPackTo(_o, _resolver);
13818	return _o;
13819	}
13820
13821	inline void NotEqualOptions::UnPackTo(NotEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13822	(void)_o;
13823	(void)_resolver;
13824	}
13825
13826	inline flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13827	return CreateNotEqualOptions(_fbb, _o, _rehasher);
13828	}
13829
13830	inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13831	(void)_rehasher;
13832	(void)_o;
13833	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13834	return tflite::CreateNotEqualOptions(
13835	_fbb);
13836	}
13837
13838	inline ShapeOptionsT ShapeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13839	auto _o = new ShapeOptionsT ();
13840	UnPackTo(_o, _resolver);
13841	return _o;
13842	}
13843
13844	inline void ShapeOptions::UnPackTo(ShapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13845	(void)_o;
13846	(void)_resolver;
13847	{ auto _e = out_type(); _o->out_type = _e; }
13848	}
13849
13850	inline flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13851	return CreateShapeOptions(_fbb, _o, _rehasher);
13852	}
13853
13854	inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13855	(void)_rehasher;
13856	(void)_o;
13857	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ShapeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13858	auto _out_type = _o->out_type;
13859	return tflite::CreateShapeOptions(
13860	_fbb,
13861	_out_type);
13862	}
13863
13864	inline RankOptionsT RankOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13865	auto _o = new RankOptionsT ();
13866	UnPackTo(_o, _resolver);
13867	return _o;
13868	}
13869
13870	inline void RankOptions::UnPackTo(RankOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13871	(void)_o;
13872	(void)_resolver;
13873	}
13874
13875	inline flatbuffers::Offset<RankOptions> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13876	return CreateRankOptions(_fbb, _o, _rehasher);
13877	}
13878
13879	inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13880	(void)_rehasher;
13881	(void)_o;
13882	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RankOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13883	return tflite::CreateRankOptions(
13884	_fbb);
13885	}
13886
13887	inline PowOptionsT PowOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13888	auto _o = new PowOptionsT ();
13889	UnPackTo(_o, _resolver);
13890	return _o;
13891	}
13892
13893	inline void PowOptions::UnPackTo(PowOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13894	(void)_o;
13895	(void)_resolver;
13896	}
13897
13898	inline flatbuffers::Offset<PowOptions> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13899	return CreatePowOptions(_fbb, _o, _rehasher);
13900	}
13901
13902	inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13903	(void)_rehasher;
13904	(void)_o;
13905	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PowOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13906	return tflite::CreatePowOptions(
13907	_fbb);
13908	}
13909
13910	inline FakeQuantOptionsT FakeQuantOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13911	auto _o = new FakeQuantOptionsT ();
13912	UnPackTo(_o, _resolver);
13913	return _o;
13914	}
13915
13916	inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13917	(void)_o;
13918	(void)_resolver;
13919	{ auto _e = min(); _o->min = _e; }
13920	{ auto _e = max(); _o->max = _e; }
13921	{ auto _e = num_bits(); _o->num_bits = _e; }
13922	{ auto _e = narrow_range(); _o->narrow_range = _e; }
13923	}
13924
13925	inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13926	return CreateFakeQuantOptions(_fbb, _o, _rehasher);
13927	}
13928
13929	inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13930	(void)_rehasher;
13931	(void)_o;
13932	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13933	auto _min = _o->min;
13934	auto _max = _o->max;
13935	auto _num_bits = _o->num_bits;
13936	auto _narrow_range = _o->narrow_range;
13937	return tflite::CreateFakeQuantOptions(
13938	_fbb,
13939	_min,
13940	_max,
13941	_num_bits,
13942	_narrow_range);
13943	}
13944
13945	inline PackOptionsT PackOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13946	auto _o = new PackOptionsT ();
13947	UnPackTo(_o, _resolver);
13948	return _o;
13949	}
13950
13951	inline void PackOptions::UnPackTo(PackOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13952	(void)_o;
13953	(void)_resolver;
13954	{ auto _e = values_count(); _o->values_count = _e; }
13955	{ auto _e = axis(); _o->axis = _e; }
13956	}
13957
13958	inline flatbuffers::Offset<PackOptions> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13959	return CreatePackOptions(_fbb, _o, _rehasher);
13960	}
13961
13962	inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13963	(void)_rehasher;
13964	(void)_o;
13965	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PackOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13966	auto _values_count = _o->values_count;
13967	auto _axis = _o->axis;
13968	return tflite::CreatePackOptions(
13969	_fbb,
13970	_values_count,
13971	_axis);
13972	}
13973
13974	inline LogicalOrOptionsT LogicalOrOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13975	auto _o = new LogicalOrOptionsT ();
13976	UnPackTo(_o, _resolver);
13977	return _o;
13978	}
13979
13980	inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13981	(void)_o;
13982	(void)_resolver;
13983	}
13984
13985	inline flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13986	return CreateLogicalOrOptions(_fbb, _o, _rehasher);
13987	}
13988
13989	inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13990	(void)_rehasher;
13991	(void)_o;
13992	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13993	return tflite::CreateLogicalOrOptions(
13994	_fbb);
13995	}
13996
13997	inline OneHotOptionsT OneHotOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13998	auto _o = new OneHotOptionsT ();
13999	UnPackTo(_o, _resolver);
14000	return _o;
14001	}
14002
14003	inline void OneHotOptions::UnPackTo(OneHotOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14004	(void)_o;
14005	(void)_resolver;
14006	{ auto _e = axis(); _o->axis = _e; }
14007	}
14008
14009	inline flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14010	return CreateOneHotOptions(_fbb, _o, _rehasher);
14011	}
14012
14013	inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14014	(void)_rehasher;
14015	(void)_o;
14016	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* OneHotOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14017	auto _axis = _o->axis;
14018	return tflite::CreateOneHotOptions(
14019	_fbb,
14020	_axis);
14021	}
14022
14023	inline AbsOptionsT AbsOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14024	auto _o = new AbsOptionsT ();
14025	UnPackTo(_o, _resolver);
14026	return _o;
14027	}
14028
14029	inline void AbsOptions::UnPackTo(AbsOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14030	(void)_o;
14031	(void)_resolver;
14032	}
14033
14034	inline flatbuffers::Offset<AbsOptions> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14035	return CreateAbsOptions(_fbb, _o, _rehasher);
14036	}
14037
14038	inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14039	(void)_rehasher;
14040	(void)_o;
14041	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AbsOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14042	return tflite::CreateAbsOptions(
14043	_fbb);
14044	}
14045
14046	inline HardSwishOptionsT HardSwishOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14047	auto _o = new HardSwishOptionsT ();
14048	UnPackTo(_o, _resolver);
14049	return _o;
14050	}
14051
14052	inline void HardSwishOptions::UnPackTo(HardSwishOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14053	(void)_o;
14054	(void)_resolver;
14055	}
14056
14057	inline flatbuffers::Offset<HardSwishOptions> HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14058	return CreateHardSwishOptions(_fbb, _o, _rehasher);
14059	}
14060
14061	inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14062	(void)_rehasher;
14063	(void)_o;
14064	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HardSwishOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14065	return tflite::CreateHardSwishOptions(
14066	_fbb);
14067	}
14068
14069	inline LogicalAndOptionsT LogicalAndOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14070	auto _o = new LogicalAndOptionsT ();
14071	UnPackTo(_o, _resolver);
14072	return _o;
14073	}
14074
14075	inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14076	(void)_o;
14077	(void)_resolver;
14078	}
14079
14080	inline flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14081	return CreateLogicalAndOptions(_fbb, _o, _rehasher);
14082	}
14083
14084	inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14085	(void)_rehasher;
14086	(void)_o;
14087	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14088	return tflite::CreateLogicalAndOptions(
14089	_fbb);
14090	}
14091
14092	inline LogicalNotOptionsT LogicalNotOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14093	auto _o = new LogicalNotOptionsT ();
14094	UnPackTo(_o, _resolver);
14095	return _o;
14096	}
14097
14098	inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14099	(void)_o;
14100	(void)_resolver;
14101	}
14102
14103	inline flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14104	return CreateLogicalNotOptions(_fbb, _o, _rehasher);
14105	}
14106
14107	inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14108	(void)_rehasher;
14109	(void)_o;
14110	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14111	return tflite::CreateLogicalNotOptions(
14112	_fbb);
14113	}
14114
14115	inline UnpackOptionsT UnpackOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14116	auto _o = new UnpackOptionsT ();
14117	UnPackTo(_o, _resolver);
14118	return _o;
14119	}
14120
14121	inline void UnpackOptions::UnPackTo(UnpackOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14122	(void)_o;
14123	(void)_resolver;
14124	{ auto _e = num(); _o->num = _e; }
14125	{ auto _e = axis(); _o->axis = _e; }
14126	}
14127
14128	inline flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14129	return CreateUnpackOptions(_fbb, _o, _rehasher);
14130	}
14131
14132	inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14133	(void)_rehasher;
14134	(void)_o;
14135	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnpackOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14136	auto _num = _o->num;
14137	auto _axis = _o->axis;
14138	return tflite::CreateUnpackOptions(
14139	_fbb,
14140	_num,
14141	_axis);
14142	}
14143
14144	inline FloorDivOptionsT FloorDivOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14145	auto _o = new FloorDivOptionsT ();
14146	UnPackTo(_o, _resolver);
14147	return _o;
14148	}
14149
14150	inline void FloorDivOptions::UnPackTo(FloorDivOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14151	(void)_o;
14152	(void)_resolver;
14153	}
14154
14155	inline flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14156	return CreateFloorDivOptions(_fbb, _o, _rehasher);
14157	}
14158
14159	inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14160	(void)_rehasher;
14161	(void)_o;
14162	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14163	return tflite::CreateFloorDivOptions(
14164	_fbb);
14165	}
14166
14167	inline SquareOptionsT SquareOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14168	auto _o = new SquareOptionsT ();
14169	UnPackTo(_o, _resolver);
14170	return _o;
14171	}
14172
14173	inline void SquareOptions::UnPackTo(SquareOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14174	(void)_o;
14175	(void)_resolver;
14176	}
14177
14178	inline flatbuffers::Offset<SquareOptions> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14179	return CreateSquareOptions(_fbb, _o, _rehasher);
14180	}
14181
14182	inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14183	(void)_rehasher;
14184	(void)_o;
14185	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SquareOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14186	return tflite::CreateSquareOptions(
14187	_fbb);
14188	}
14189
14190	inline ZerosLikeOptionsT ZerosLikeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14191	auto _o = new ZerosLikeOptionsT ();
14192	UnPackTo(_o, _resolver);
14193	return _o;
14194	}
14195
14196	inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14197	(void)_o;
14198	(void)_resolver;
14199	}
14200
14201	inline flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14202	return CreateZerosLikeOptions(_fbb, _o, _rehasher);
14203	}
14204
14205	inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14206	(void)_rehasher;
14207	(void)_o;
14208	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14209	return tflite::CreateZerosLikeOptions(
14210	_fbb);
14211	}
14212
14213	inline FillOptionsT FillOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14214	auto _o = new FillOptionsT ();
14215	UnPackTo(_o, _resolver);
14216	return _o;
14217	}
14218
14219	inline void FillOptions::UnPackTo(FillOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14220	(void)_o;
14221	(void)_resolver;
14222	}
14223
14224	inline flatbuffers::Offset<FillOptions> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14225	return CreateFillOptions(_fbb, _o, _rehasher);
14226	}
14227
14228	inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14229	(void)_rehasher;
14230	(void)_o;
14231	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FillOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14232	return tflite::CreateFillOptions(
14233	_fbb);
14234	}
14235
14236	inline FloorModOptionsT FloorModOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14237	auto _o = new FloorModOptionsT ();
14238	UnPackTo(_o, _resolver);
14239	return _o;
14240	}
14241
14242	inline void FloorModOptions::UnPackTo(FloorModOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14243	(void)_o;
14244	(void)_resolver;
14245	}
14246
14247	inline flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14248	return CreateFloorModOptions(_fbb, _o, _rehasher);
14249	}
14250
14251	inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14252	(void)_rehasher;
14253	(void)_o;
14254	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FloorModOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14255	return tflite::CreateFloorModOptions(
14256	_fbb);
14257	}
14258
14259	inline RangeOptionsT RangeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14260	auto _o = new RangeOptionsT ();
14261	UnPackTo(_o, _resolver);
14262	return _o;
14263	}
14264
14265	inline void RangeOptions::UnPackTo(RangeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14266	(void)_o;
14267	(void)_resolver;
14268	}
14269
14270	inline flatbuffers::Offset<RangeOptions> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14271	return CreateRangeOptions(_fbb, _o, _rehasher);
14272	}
14273
14274	inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14275	(void)_rehasher;
14276	(void)_o;
14277	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RangeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14278	return tflite::CreateRangeOptions(
14279	_fbb);
14280	}
14281
14282	inline LeakyReluOptionsT LeakyReluOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14283	auto _o = new LeakyReluOptionsT ();
14284	UnPackTo(_o, _resolver);
14285	return _o;
14286	}
14287
14288	inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14289	(void)_o;
14290	(void)_resolver;
14291	{ auto _e = alpha(); _o->alpha = _e; }
14292	}
14293
14294	inline flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14295	return CreateLeakyReluOptions(_fbb, _o, _rehasher);
14296	}
14297
14298	inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14299	(void)_rehasher;
14300	(void)_o;
14301	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14302	auto _alpha = _o->alpha;
14303	return tflite::CreateLeakyReluOptions(
14304	_fbb,
14305	_alpha);
14306	}
14307
14308	inline SquaredDifferenceOptionsT SquaredDifferenceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14309	auto _o = new SquaredDifferenceOptionsT ();
14310	UnPackTo(_o, _resolver);
14311	return _o;
14312	}
14313
14314	inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14315	(void)_o;
14316	(void)_resolver;
14317	}
14318
14319	inline flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14320	return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
14321	}
14322
14323	inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14324	(void)_rehasher;
14325	(void)_o;
14326	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14327	return tflite::CreateSquaredDifferenceOptions(
14328	_fbb);
14329	}
14330
14331	inline MirrorPadOptionsT MirrorPadOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14332	auto _o = new MirrorPadOptionsT ();
14333	UnPackTo(_o, _resolver);
14334	return _o;
14335	}
14336
14337	inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14338	(void)_o;
14339	(void)_resolver;
14340	{ auto _e = mode(); _o->mode = _e; }
14341	}
14342
14343	inline flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14344	return CreateMirrorPadOptions(_fbb, _o, _rehasher);
14345	}
14346
14347	inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14348	(void)_rehasher;
14349	(void)_o;
14350	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14351	auto _mode = _o->mode;
14352	return tflite::CreateMirrorPadOptions(
14353	_fbb,
14354	_mode);
14355	}
14356
14357	inline UniqueOptionsT UniqueOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14358	auto _o = new UniqueOptionsT ();
14359	UnPackTo(_o, _resolver);
14360	return _o;
14361	}
14362
14363	inline void UniqueOptions::UnPackTo(UniqueOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14364	(void)_o;
14365	(void)_resolver;
14366	{ auto _e = idx_out_type(); _o->idx_out_type = _e; }
14367	}
14368
14369	inline flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14370	return CreateUniqueOptions(_fbb, _o, _rehasher);
14371	}
14372
14373	inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14374	(void)_rehasher;
14375	(void)_o;
14376	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UniqueOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14377	auto _idx_out_type = _o->idx_out_type;
14378	return tflite::CreateUniqueOptions(
14379	_fbb,
14380	_idx_out_type);
14381	}
14382
14383	inline ReverseV2OptionsT ReverseV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14384	auto _o = new ReverseV2OptionsT ();
14385	UnPackTo(_o, _resolver);
14386	return _o;
14387	}
14388
14389	inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14390	(void)_o;
14391	(void)_resolver;
14392	}
14393
14394	inline flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14395	return CreateReverseV2Options(_fbb, _o, _rehasher);
14396	}
14397
14398	inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14399	(void)_rehasher;
14400	(void)_o;
14401	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14402	return tflite::CreateReverseV2Options(
14403	_fbb);
14404	}
14405
14406	inline AddNOptionsT AddNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14407	auto _o = new AddNOptionsT ();
14408	UnPackTo(_o, _resolver);
14409	return _o;
14410	}
14411
14412	inline void AddNOptions::UnPackTo(AddNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14413	(void)_o;
14414	(void)_resolver;
14415	}
14416
14417	inline flatbuffers::Offset<AddNOptions> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14418	return CreateAddNOptions(_fbb, _o, _rehasher);
14419	}
14420
14421	inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14422	(void)_rehasher;
14423	(void)_o;
14424	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AddNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14425	return tflite::CreateAddNOptions(
14426	_fbb);
14427	}
14428
14429	inline GatherNdOptionsT GatherNdOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14430	auto _o = new GatherNdOptionsT ();
14431	UnPackTo(_o, _resolver);
14432	return _o;
14433	}
14434
14435	inline void GatherNdOptions::UnPackTo(GatherNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14436	(void)_o;
14437	(void)_resolver;
14438	}
14439
14440	inline flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14441	return CreateGatherNdOptions(_fbb, _o, _rehasher);
14442	}
14443
14444	inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14445	(void)_rehasher;
14446	(void)_o;
14447	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14448	return tflite::CreateGatherNdOptions(
14449	_fbb);
14450	}
14451
14452	inline WhereOptionsT WhereOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14453	auto _o = new WhereOptionsT ();
14454	UnPackTo(_o, _resolver);
14455	return _o;
14456	}
14457
14458	inline void WhereOptions::UnPackTo(WhereOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14459	(void)_o;
14460	(void)_resolver;
14461	}
14462
14463	inline flatbuffers::Offset<WhereOptions> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14464	return CreateWhereOptions(_fbb, _o, _rehasher);
14465	}
14466
14467	inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14468	(void)_rehasher;
14469	(void)_o;
14470	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* WhereOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14471	return tflite::CreateWhereOptions(
14472	_fbb);
14473	}
14474
14475	inline ReverseSequenceOptionsT ReverseSequenceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14476	auto _o = new ReverseSequenceOptionsT ();
14477	UnPackTo(_o, _resolver);
14478	return _o;
14479	}
14480
14481	inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14482	(void)_o;
14483	(void)_resolver;
14484	{ auto _e = seq_dim(); _o->seq_dim = _e; }
14485	{ auto _e = batch_dim(); _o->batch_dim = _e; }
14486	}
14487
14488	inline flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14489	return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
14490	}
14491
14492	inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14493	(void)_rehasher;
14494	(void)_o;
14495	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14496	auto _seq_dim = _o->seq_dim;
14497	auto _batch_dim = _o->batch_dim;
14498	return tflite::CreateReverseSequenceOptions(
14499	_fbb,
14500	_seq_dim,
14501	_batch_dim);
14502	}
14503
14504	inline MatrixDiagOptionsT MatrixDiagOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14505	auto _o = new MatrixDiagOptionsT ();
14506	UnPackTo(_o, _resolver);
14507	return _o;
14508	}
14509
14510	inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14511	(void)_o;
14512	(void)_resolver;
14513	}
14514
14515	inline flatbuffers::Offset<MatrixDiagOptions> MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14516	return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
14517	}
14518
14519	inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14520	(void)_rehasher;
14521	(void)_o;
14522	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MatrixDiagOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14523	return tflite::CreateMatrixDiagOptions(
14524	_fbb);
14525	}
14526
14527	inline QuantizeOptionsT QuantizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14528	auto _o = new QuantizeOptionsT ();
14529	UnPackTo(_o, _resolver);
14530	return _o;
14531	}
14532
14533	inline void QuantizeOptions::UnPackTo(QuantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14534	(void)_o;
14535	(void)_resolver;
14536	}
14537
14538	inline flatbuffers::Offset<QuantizeOptions> QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14539	return CreateQuantizeOptions(_fbb, _o, _rehasher);
14540	}
14541
14542	inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14543	(void)_rehasher;
14544	(void)_o;
14545	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* QuantizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14546	return tflite::CreateQuantizeOptions(
14547	_fbb);
14548	}
14549
14550	inline MatrixSetDiagOptionsT MatrixSetDiagOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14551	auto _o = new MatrixSetDiagOptionsT ();
14552	UnPackTo(_o, _resolver);
14553	return _o;
14554	}
14555
14556	inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14557	(void)_o;
14558	(void)_resolver;
14559	}
14560
14561	inline flatbuffers::Offset<MatrixSetDiagOptions> MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14562	return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
14563	}
14564
14565	inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14566	(void)_rehasher;
14567	(void)_o;
14568	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MatrixSetDiagOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14569	return tflite::CreateMatrixSetDiagOptions(
14570	_fbb);
14571	}
14572
14573	inline IfOptionsT IfOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14574	auto _o = new IfOptionsT ();
14575	UnPackTo(_o, _resolver);
14576	return _o;
14577	}
14578
14579	inline void IfOptions::UnPackTo(IfOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14580	(void)_o;
14581	(void)_resolver;
14582	{ auto _e = then_subgraph_index(); _o->then_subgraph_index = _e; }
14583	{ auto _e = else_subgraph_index(); _o->else_subgraph_index = _e; }
14584	}
14585
14586	inline flatbuffers::Offset<IfOptions> IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14587	return CreateIfOptions(_fbb, _o, _rehasher);
14588	}
14589
14590	inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14591	(void)_rehasher;
14592	(void)_o;
14593	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* IfOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14594	auto _then_subgraph_index = _o->then_subgraph_index;
14595	auto _else_subgraph_index = _o->else_subgraph_index;
14596	return tflite::CreateIfOptions(
14597	_fbb,
14598	_then_subgraph_index,
14599	_else_subgraph_index);
14600	}
14601
14602	inline CallOnceOptionsT CallOnceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14603	auto _o = new CallOnceOptionsT ();
14604	UnPackTo(_o, _resolver);
14605	return _o;
14606	}
14607
14608	inline void CallOnceOptions::UnPackTo(CallOnceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14609	(void)_o;
14610	(void)_resolver;
14611	{ auto _e = init_subgraph_index(); _o->init_subgraph_index = _e; }
14612	}
14613
14614	inline flatbuffers::Offset<CallOnceOptions> CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14615	return CreateCallOnceOptions(_fbb, _o, _rehasher);
14616	}
14617
14618	inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14619	(void)_rehasher;
14620	(void)_o;
14621	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CallOnceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14622	auto _init_subgraph_index = _o->init_subgraph_index;
14623	return tflite::CreateCallOnceOptions(
14624	_fbb,
14625	_init_subgraph_index);
14626	}
14627
14628	inline WhileOptionsT WhileOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14629	auto _o = new WhileOptionsT ();
14630	UnPackTo(_o, _resolver);
14631	return _o;
14632	}
14633
14634	inline void WhileOptions::UnPackTo(WhileOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14635	(void)_o;
14636	(void)_resolver;
14637	{ auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; }
14638	{ auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; }
14639	}
14640
14641	inline flatbuffers::Offset<WhileOptions> WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14642	return CreateWhileOptions(_fbb, _o, _rehasher);
14643	}
14644
14645	inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14646	(void)_rehasher;
14647	(void)_o;
14648	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* WhileOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14649	auto _cond_subgraph_index = _o->cond_subgraph_index;
14650	auto _body_subgraph_index = _o->body_subgraph_index;
14651	return tflite::CreateWhileOptions(
14652	_fbb,
14653	_cond_subgraph_index,
14654	_body_subgraph_index);
14655	}
14656
14657	inline NonMaxSuppressionV4OptionsT NonMaxSuppressionV4Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14658	auto _o = new NonMaxSuppressionV4OptionsT ();
14659	UnPackTo(_o, _resolver);
14660	return _o;
14661	}
14662
14663	inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14664	(void)_o;
14665	(void)_resolver;
14666	}
14667
14668	inline flatbuffers::Offset<NonMaxSuppressionV4Options> NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14669	return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
14670	}
14671
14672	inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14673	(void)_rehasher;
14674	(void)_o;
14675	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NonMaxSuppressionV4OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14676	return tflite::CreateNonMaxSuppressionV4Options(
14677	_fbb);
14678	}
14679
14680	inline NonMaxSuppressionV5OptionsT NonMaxSuppressionV5Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14681	auto _o = new NonMaxSuppressionV5OptionsT ();
14682	UnPackTo(_o, _resolver);
14683	return _o;
14684	}
14685
14686	inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14687	(void)_o;
14688	(void)_resolver;
14689	}
14690
14691	inline flatbuffers::Offset<NonMaxSuppressionV5Options> NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14692	return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
14693	}
14694
14695	inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14696	(void)_rehasher;
14697	(void)_o;
14698	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NonMaxSuppressionV5OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14699	return tflite::CreateNonMaxSuppressionV5Options(
14700	_fbb);
14701	}
14702
14703	inline ScatterNdOptionsT ScatterNdOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14704	auto _o = new ScatterNdOptionsT ();
14705	UnPackTo(_o, _resolver);
14706	return _o;
14707	}
14708
14709	inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14710	(void)_o;
14711	(void)_resolver;
14712	}
14713
14714	inline flatbuffers::Offset<ScatterNdOptions> ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14715	return CreateScatterNdOptions(_fbb, _o, _rehasher);
14716	}
14717
14718	inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14719	(void)_rehasher;
14720	(void)_o;
14721	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ScatterNdOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14722	return tflite::CreateScatterNdOptions(
14723	_fbb);
14724	}
14725
14726	inline SelectV2OptionsT SelectV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14727	auto _o = new SelectV2OptionsT ();
14728	UnPackTo(_o, _resolver);
14729	return _o;
14730	}
14731
14732	inline void SelectV2Options::UnPackTo(SelectV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14733	(void)_o;
14734	(void)_resolver;
14735	}
14736
14737	inline flatbuffers::Offset<SelectV2Options> SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14738	return CreateSelectV2Options(_fbb, _o, _rehasher);
14739	}
14740
14741	inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14742	(void)_rehasher;
14743	(void)_o;
14744	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SelectV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14745	return tflite::CreateSelectV2Options(
14746	_fbb);
14747	}
14748
14749	inline DensifyOptionsT DensifyOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14750	auto _o = new DensifyOptionsT ();
14751	UnPackTo(_o, _resolver);
14752	return _o;
14753	}
14754
14755	inline void DensifyOptions::UnPackTo(DensifyOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14756	(void)_o;
14757	(void)_resolver;
14758	}
14759
14760	inline flatbuffers::Offset<DensifyOptions> DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14761	return CreateDensifyOptions(_fbb, _o, _rehasher);
14762	}
14763
14764	inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14765	(void)_rehasher;
14766	(void)_o;
14767	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DensifyOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14768	return tflite::CreateDensifyOptions(
14769	_fbb);
14770	}
14771
14772	inline SegmentSumOptionsT SegmentSumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14773	auto _o = new SegmentSumOptionsT ();
14774	UnPackTo(_o, _resolver);
14775	return _o;
14776	}
14777
14778	inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14779	(void)_o;
14780	(void)_resolver;
14781	}
14782
14783	inline flatbuffers::Offset<SegmentSumOptions> SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14784	return CreateSegmentSumOptions(_fbb, _o, _rehasher);
14785	}
14786
14787	inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14788	(void)_rehasher;
14789	(void)_o;
14790	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14791	return tflite::CreateSegmentSumOptions(
14792	_fbb);
14793	}
14794
14795	inline BatchMatMulOptionsT BatchMatMulOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14796	auto _o = new BatchMatMulOptionsT ();
14797	UnPackTo(_o, _resolver);
14798	return _o;
14799	}
14800
14801	inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14802	(void)_o;
14803	(void)_resolver;
14804	{ auto _e = adj_x(); _o->adj_x = _e; }
14805	{ auto _e = adj_y(); _o->adj_y = _e; }
14806	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14807	}
14808
14809	inline flatbuffers::Offset<BatchMatMulOptions> BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14810	return CreateBatchMatMulOptions(_fbb, _o, _rehasher);
14811	}
14812
14813	inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14814	(void)_rehasher;
14815	(void)_o;
14816	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BatchMatMulOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14817	auto _adj_x = _o->adj_x;
14818	auto _adj_y = _o->adj_y;
14819	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14820	return tflite::CreateBatchMatMulOptions(
14821	_fbb,
14822	_adj_x,
14823	_adj_y,
14824	_asymmetric_quantize_inputs);
14825	}
14826
14827	inline CumsumOptionsT CumsumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14828	auto _o = new CumsumOptionsT ();
14829	UnPackTo(_o, _resolver);
14830	return _o;
14831	}
14832
14833	inline void CumsumOptions::UnPackTo(CumsumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14834	(void)_o;
14835	(void)_resolver;
14836	{ auto _e = exclusive(); _o->exclusive = _e; }
14837	{ auto _e = reverse(); _o->reverse = _e; }
14838	}
14839
14840	inline flatbuffers::Offset<CumsumOptions> CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14841	return CreateCumsumOptions(_fbb, _o, _rehasher);
14842	}
14843
14844	inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14845	(void)_rehasher;
14846	(void)_o;
14847	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CumsumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14848	auto _exclusive = _o->exclusive;
14849	auto _reverse = _o->reverse;
14850	return tflite::CreateCumsumOptions(
14851	_fbb,
14852	_exclusive,
14853	_reverse);
14854	}
14855
14856	inline BroadcastToOptionsT BroadcastToOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14857	auto _o = new BroadcastToOptionsT ();
14858	UnPackTo(_o, _resolver);
14859	return _o;
14860	}
14861
14862	inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14863	(void)_o;
14864	(void)_resolver;
14865	}
14866
14867	inline flatbuffers::Offset<BroadcastToOptions> BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14868	return CreateBroadcastToOptions(_fbb, _o, _rehasher);
14869	}
14870
14871	inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14872	(void)_rehasher;
14873	(void)_o;
14874	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BroadcastToOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14875	return tflite::CreateBroadcastToOptions(
14876	_fbb);
14877	}
14878
14879	inline Rfft2dOptionsT Rfft2dOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14880	auto _o = new Rfft2dOptionsT ();
14881	UnPackTo(_o, _resolver);
14882	return _o;
14883	}
14884
14885	inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14886	(void)_o;
14887	(void)_resolver;
14888	}
14889
14890	inline flatbuffers::Offset<Rfft2dOptions> Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14891	return CreateRfft2dOptions(_fbb, _o, _rehasher);
14892	}
14893
14894	inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14895	(void)_rehasher;
14896	(void)_o;
14897	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Rfft2dOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14898	return tflite::CreateRfft2dOptions(
14899	_fbb);
14900	}
14901
14902	inline HashtableOptionsT HashtableOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14903	auto _o = new HashtableOptionsT ();
14904	UnPackTo(_o, _resolver);
14905	return _o;
14906	}
14907
14908	inline void HashtableOptions::UnPackTo(HashtableOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14909	(void)_o;
14910	(void)_resolver;
14911	{ auto _e = table_id(); _o->table_id = _e; }
14912	{ auto _e = key_dtype(); _o->key_dtype = _e; }
14913	{ auto _e = value_dtype(); _o->value_dtype = _e; }
14914	}
14915
14916	inline flatbuffers::Offset<HashtableOptions> HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14917	return CreateHashtableOptions(_fbb, _o, _rehasher);
14918	}
14919
14920	inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14921	(void)_rehasher;
14922	(void)_o;
14923	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14924	auto _table_id = _o->table_id;
14925	auto _key_dtype = _o->key_dtype;
14926	auto _value_dtype = _o->value_dtype;
14927	return tflite::CreateHashtableOptions(
14928	_fbb,
14929	_table_id,
14930	_key_dtype,
14931	_value_dtype);
14932	}
14933
14934	inline HashtableFindOptionsT HashtableFindOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14935	auto _o = new HashtableFindOptionsT ();
14936	UnPackTo(_o, _resolver);
14937	return _o;
14938	}
14939
14940	inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14941	(void)_o;
14942	(void)_resolver;
14943	}
14944
14945	inline flatbuffers::Offset<HashtableFindOptions> HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14946	return CreateHashtableFindOptions(_fbb, _o, _rehasher);
14947	}
14948
14949	inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14950	(void)_rehasher;
14951	(void)_o;
14952	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableFindOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14953	return tflite::CreateHashtableFindOptions(
14954	_fbb);
14955	}
14956
14957	inline HashtableImportOptionsT HashtableImportOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14958	auto _o = new HashtableImportOptionsT ();
14959	UnPackTo(_o, _resolver);
14960	return _o;
14961	}
14962
14963	inline void HashtableImportOptions::UnPackTo(HashtableImportOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14964	(void)_o;
14965	(void)_resolver;
14966	}
14967
14968	inline flatbuffers::Offset<HashtableImportOptions> HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14969	return CreateHashtableImportOptions(_fbb, _o, _rehasher);
14970	}
14971
14972	inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14973	(void)_rehasher;
14974	(void)_o;
14975	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableImportOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14976	return tflite::CreateHashtableImportOptions(
14977	_fbb);
14978	}
14979
14980	inline HashtableSizeOptionsT HashtableSizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14981	auto _o = new HashtableSizeOptionsT ();
14982	UnPackTo(_o, _resolver);
14983	return _o;
14984	}
14985
14986	inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14987	(void)_o;
14988	(void)_resolver;
14989	}
14990
14991	inline flatbuffers::Offset<HashtableSizeOptions> HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14992	return CreateHashtableSizeOptions(_fbb, _o, _rehasher);
14993	}
14994
14995	inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14996	(void)_rehasher;
14997	(void)_o;
14998	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableSizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14999	return tflite::CreateHashtableSizeOptions(
15000	_fbb);
15001	}
15002
15003	inline OperatorCodeT OperatorCode::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15004	auto _o = new OperatorCodeT ();
15005	UnPackTo(_o, _resolver);
15006	return _o;
15007	}
15008
15009	inline void OperatorCode::UnPackTo(OperatorCodeT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15010	(void)_o;
15011	(void)_resolver;
15012	{ auto _e = deprecated_builtin_code(); _o->deprecated_builtin_code = _e; }
15013	{ auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); }
15014	{ auto _e = version(); _o->version = _e; }
15015	{ auto _e = builtin_code(); _o->builtin_code = _e; }
15016	}
15017
15018	inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15019	return CreateOperatorCode(_fbb, _o, _rehasher);
15020	}
15021
15022	inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15023	(void)_rehasher;
15024	(void)_o;
15025	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* OperatorCodeT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15026	auto _deprecated_builtin_code = _o->deprecated_builtin_code;
15027	auto _custom_code = _o->custom_code.empty() ? `0` : _fbb.CreateString(_o->custom_code);
15028	auto _version = _o->version;
15029	auto _builtin_code = _o->builtin_code;
15030	return tflite::CreateOperatorCode(
15031	_fbb,
15032	_deprecated_builtin_code,
15033	_custom_code,
15034	_version,
15035	_builtin_code);
15036	}
15037
15038	inline OperatorT Operator::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15039	auto _o = new OperatorT ();
15040	UnPackTo(_o, _resolver);
15041	return _o;
15042	}
15043
15044	inline void Operator::UnPackTo(OperatorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15045	(void)_o;
15046	(void)_resolver;
15047	{ auto _e = opcode_index(); _o->opcode_index = _e; }
15048	{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }
15049	{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }
15050	{ auto _e = builtin_options_type(); _o->builtin_options.type = _e; }
15051	{ auto _e = builtin_options(); if (_e) _o->builtin_options.value = tflite::BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); }
15052	{ auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom_options.begin()); } }
15053	{ auto _e = custom_options_format(); _o->custom_options_format = _e; }
15054	{ auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != `0`; } } }
15055	{ auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->intermediates[_i] = _e->Get(_i); } } }
15056	}
15057
15058	inline flatbuffers::Offset<Operator> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15059	return CreateOperator(_fbb, _o, _rehasher);
15060	}
15061
15062	inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15063	(void)_rehasher;
15064	(void)_o;
15065	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* OperatorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15066	auto _opcode_index = _o->opcode_index;
15067	auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : `0`;
15068	auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : `0`;
15069	auto _builtin_options_type = _o->builtin_options.type;
15070	auto _builtin_options = _o->builtin_options.Pack(_fbb);
15071	auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : `0`;
15072	auto _custom_options_format = _o->custom_options_format;
15073	auto _mutating_variable_inputs = _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : `0`;
15074	auto _intermediates = _o->intermediates.size() ? _fbb.CreateVector(_o->intermediates) : `0`;
15075	return tflite::CreateOperator(
15076	_fbb,
15077	_opcode_index,
15078	_inputs,
15079	_outputs,
15080	_builtin_options_type,
15081	_builtin_options,
15082	_custom_options,
15083	_custom_options_format,
15084	_mutating_variable_inputs,
15085	_intermediates);
15086	}
15087
15088	inline SubGraphT SubGraph::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15089	auto _o = new SubGraphT ();
15090	UnPackTo(_o, _resolver);
15091	return _o;
15092	}
15093
15094	inline void SubGraph::UnPackTo(SubGraphT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15095	(void)_o;
15096	(void)_resolver;
15097	{ auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->tensors[_i] = std::unique_ptr<tflite::TensorT>(_e->Get(_i)->UnPack(_resolver)); } } }
15098	{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }
15099	{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }
15100	{ auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->operators[_i] = std::unique_ptr<tflite::OperatorT>(_e->Get(_i)->UnPack(_resolver)); } } }
15101	{ auto _e = name(); if (_e) _o->name = _e->str(); }
15102	}
15103
15104	inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15105	return CreateSubGraph(_fbb, _o, _rehasher);
15106	}
15107
15108	inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15109	(void)_rehasher;
15110	(void)_o;
15111	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SubGraphT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15112	auto _tensors = _o->tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>> (_o->tensors.size(), [](size_t i, _VectorArgs __va) { return* CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : `0`;
15113	auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : `0`;
15114	auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : `0`;
15115	auto _operators = _o->operators.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>> (_o->operators.size(), [](size_t i, _VectorArgs __va) { return* CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : `0`;
15116	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
15117	return tflite::CreateSubGraph(
15118	_fbb,
15119	_tensors,
15120	_inputs,
15121	_outputs,
15122	_operators,
15123	_name);
15124	}
15125
15126	inline BufferT Buffer::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15127	auto _o = new BufferT ();
15128	UnPackTo(_o, _resolver);
15129	return _o;
15130	}
15131
15132	inline void Buffer::UnPackTo(BufferT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15133	(void)_o;
15134	(void)_resolver;
15135	{ auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
15136	}
15137
15138	inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15139	return CreateBuffer(_fbb, _o, _rehasher);
15140	}
15141
15142	inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15143	(void)_rehasher;
15144	(void)_o;
15145	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BufferT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15146	_fbb.ForceVectorAlignment(_o->data.size(), sizeof(uint8_t), `16`);
15147	auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : `0`;
15148	return tflite::CreateBuffer(
15149	_fbb,
15150	_data);
15151	}
15152
15153	inline MetadataT Metadata::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15154	auto _o = new MetadataT ();
15155	UnPackTo(_o, _resolver);
15156	return _o;
15157	}
15158
15159	inline void Metadata::UnPackTo(MetadataT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15160	(void)_o;
15161	(void)_resolver;
15162	{ auto _e = name(); if (_e) _o->name = _e->str(); }
15163	{ auto _e = buffer(); _o->buffer = _e; }
15164	}
15165
15166	inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15167	return CreateMetadata(_fbb, _o, _rehasher);
15168	}
15169
15170	inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15171	(void)_rehasher;
15172	(void)_o;
15173	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MetadataT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15174	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
15175	auto _buffer = _o->buffer;
15176	return tflite::CreateMetadata(
15177	_fbb,
15178	_name,
15179	_buffer);
15180	}
15181
15182	inline TensorMapT TensorMap::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15183	auto _o = new TensorMapT ();
15184	UnPackTo(_o, _resolver);
15185	return _o;
15186	}
15187
15188	inline void TensorMap::UnPackTo(TensorMapT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15189	(void)_o;
15190	(void)_resolver;
15191	{ auto _e = name(); if (_e) _o->name = _e->str(); }
15192	{ auto _e = tensor_index(); _o->tensor_index = _e; }
15193	}
15194
15195	inline flatbuffers::Offset<TensorMap> TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15196	return CreateTensorMap(_fbb, _o, _rehasher);
15197	}
15198
15199	inline flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15200	(void)_rehasher;
15201	(void)_o;
15202	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TensorMapT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15203	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
15204	auto _tensor_index = _o->tensor_index;
15205	return tflite::CreateTensorMap(
15206	_fbb,
15207	_name,
15208	_tensor_index);
15209	}
15210
15211	inline SignatureDefT SignatureDef::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15212	auto _o = new SignatureDefT ();
15213	UnPackTo(_o, _resolver);
15214	return _o;
15215	}
15216
15217	inline void SignatureDef::UnPackTo(SignatureDefT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15218	(void)_o;
15219	(void)_resolver;
15220	{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->inputs[_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); } } }
15221	{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->outputs[_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); } } }
15222	{ auto _e = method_name(); if (_e) _o->method_name = _e->str(); }
15223	{ auto _e = key(); if (_e) _o->key = _e->str(); }
15224	}
15225
15226	inline flatbuffers::Offset<SignatureDef> SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15227	return CreateSignatureDef(_fbb, _o, _rehasher);
15228	}
15229
15230	inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15231	(void)_rehasher;
15232	(void)_o;
15233	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SignatureDefT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15234	auto _inputs = _o->inputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->inputs.size(), [](size_t i, _VectorArgs __va) { return* CreateTensorMap(*__va->__fbb, __va->__o->inputs[i].get(), __va->__rehasher); }, &_va ) : `0`;
15235	auto _outputs = _o->outputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->outputs.size(), [](size_t i, _VectorArgs __va) { return* CreateTensorMap(*__va->__fbb, __va->__o->outputs[i].get(), __va->__rehasher); }, &_va ) : `0`;
15236	auto _method_name = _o->method_name.empty() ? `0` : _fbb.CreateString(_o->method_name);
15237	auto _key = _o->key.empty() ? `0` : _fbb.CreateString(_o->key);
15238	return tflite::CreateSignatureDef(
15239	_fbb,
15240	_inputs,
15241	_outputs,
15242	_method_name,
15243	_key);
15244	}
15245
15246	inline ModelT Model::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15247	auto _o = new ModelT ();
15248	UnPackTo(_o, _resolver);
15249	return _o;
15250	}
15251
15252	inline void Model::UnPackTo(ModelT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15253	(void)_o;
15254	(void)_resolver;
15255	{ auto _e = version(); _o->version = _e; }
15256	{ auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->operator_codes[_i] = std::unique_ptr<tflite::OperatorCodeT>(_e->Get(_i)->UnPack(_resolver)); } } }
15257	{ auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->subgraphs[_i] = std::unique_ptr<tflite::SubGraphT>(_e->Get(_i)->UnPack(_resolver)); } } }
15258	{ auto _e = description(); if (_e) _o->description = _e->str(); }
15259	{ auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->buffers[_i] = std::unique_ptr<tflite::BufferT>(_e->Get(_i)->UnPack(_resolver)); } } }
15260	{ auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } }
15261	{ auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->metadata[_i] = std::unique_ptr<tflite::MetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
15262	{ auto _e = signature_defs(); if (_e) { _o->signature_defs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->signature_defs[_i] = std::unique_ptr<tflite::SignatureDefT>(_e->Get(_i)->UnPack(_resolver)); } } }
15263	}
15264
15265	inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15266	return CreateModel(_fbb, _o, _rehasher);
15267	}
15268
15269	inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15270	(void)_rehasher;
15271	(void)_o;
15272	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ModelT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15273	auto _version = _o->version;
15274	auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs __va) { return* CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : `0`;
15275	auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs __va) { return* CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : `0`;
15276	auto _description = _o->description.empty() ? `0` : _fbb.CreateString(_o->description);
15277	auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs __va) { return* CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : `0`;
15278	auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : `0`;
15279	auto _metadata = _o->metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>> (_o->metadata.size(), [](size_t i, _VectorArgs __va) { return* CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher); }, &_va ) : `0`;
15280	auto _signature_defs = _o->signature_defs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>> (_o->signature_defs.size(), [](size_t i, _VectorArgs __va) { return* CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs[i].get(), __va->__rehasher); }, &_va ) : `0`;
15281	return tflite::CreateModel(
15282	_fbb,
15283	_version,
15284	_operator_codes,
15285	_subgraphs,
15286	_description,
15287	_buffers,
15288	_metadata_buffer,
15289	_metadata,
15290	_signature_defs);
15291	}
15292
15293	inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) {
15294	switch (type) {
15295	case QuantizationDetails_NONE: {
15296	return true;
15297	}
15298	case QuantizationDetails_CustomQuantization: {
15299	auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
15300	return verifier.VerifyTable(ptr);
15301	}
15302	default: return true;
15303	}
15304	}
15305
15306	inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types) {
15307	if (!values \|\| !types) return !values && !types;
15308	if (values->size() != types->size()) return false;
15309	for (flatbuffers::uoffset_t i = `0`; i < values->size(); ++i) {
15310	if (!VerifyQuantizationDetails(
15311	verifier, values->Get(i), types->GetEnum<QuantizationDetails>(i))) {
15312	return false;
15313	}
15314	}
15315	return true;
15316	}
15317
15318	inline void QuantizationDetailsUnion::UnPack(const* void obj, QuantizationDetails type, const* flatbuffers::resolver_function_t *resolver) {
15319	switch (type) {
15320	case QuantizationDetails_CustomQuantization: {
15321	auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
15322	return ptr->UnPack(resolver);
15323	}
15324	default: return nullptr;
15325	}
15326	}
15327
15328	inline flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher) const* {
15329	switch (type) {
15330	case QuantizationDetails_CustomQuantization: {
15331	auto ptr = reinterpret_cast<const tflite::CustomQuantizationT *>(value);
15332	return CreateCustomQuantization(_fbb, ptr, _rehasher).Union();
15333	}
15334	default: return `0`;
15335	}
15336	}
15337
15338	inline QuantizationDetailsUnion::QuantizationDetailsUnion(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
15339	switch (type) {
15340	case QuantizationDetails_CustomQuantization: {
15341	value = new tflite::CustomQuantizationT (*reinterpret_cast<tflite::CustomQuantizationT *>(u.value));
15342	break;
15343	}
15344	default:
15345	break;
15346	}
15347	}
15348
15349	inline void QuantizationDetailsUnion::Reset() {
15350	switch (type) {
15351	case QuantizationDetails_CustomQuantization: {
15352	auto ptr = reinterpret_cast<tflite::CustomQuantizationT *>(value);
15353	delete ptr;
15354	break;
15355	}
15356	default: break;
15357	}
15358	value = nullptr;
15359	type = QuantizationDetails_NONE;
15360	}
15361
15362	inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) {
15363	switch (type) {
15364	case SparseIndexVector_NONE: {
15365	return true;
15366	}
15367	case SparseIndexVector_Int32Vector: {
15368	auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
15369	return verifier.VerifyTable(ptr);
15370	}
15371	case SparseIndexVector_Uint16Vector: {
15372	auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
15373	return verifier.VerifyTable(ptr);
15374	}
15375	case SparseIndexVector_Uint8Vector: {
15376	auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
15377	return verifier.VerifyTable(ptr);
15378	}
15379	default: return true;
15380	}
15381	}
15382
15383	inline bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types) {
15384	if (!values \|\| !types) return !values && !types;
15385	if (values->size() != types->size()) return false;
15386	for (flatbuffers::uoffset_t i = `0`; i < values->size(); ++i) {
15387	if (!VerifySparseIndexVector(
15388	verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i))) {
15389	return false;
15390	}
15391	}
15392	return true;
15393	}
15394
15395	inline void SparseIndexVectorUnion::UnPack(const* void obj, SparseIndexVector type, const* flatbuffers::resolver_function_t *resolver) {
15396	switch (type) {
15397	case SparseIndexVector_Int32Vector: {
15398	auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
15399	return ptr->UnPack(resolver);
15400	}
15401	case SparseIndexVector_Uint16Vector: {
15402	auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
15403	return ptr->UnPack(resolver);
15404	}
15405	case SparseIndexVector_Uint8Vector: {
15406	auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
15407	return ptr->UnPack(resolver);
15408	}
15409	default: return nullptr;
15410	}
15411	}
15412
15413	inline flatbuffers::Offset<void> SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher) const* {
15414	switch (type) {
15415	case SparseIndexVector_Int32Vector: {
15416	auto ptr = reinterpret_cast<const tflite::Int32VectorT *>(value);
15417	return CreateInt32Vector(_fbb, ptr, _rehasher).Union();
15418	}
15419	case SparseIndexVector_Uint16Vector: {
15420	auto ptr = reinterpret_cast<const tflite::Uint16VectorT *>(value);
15421	return CreateUint16Vector(_fbb, ptr, _rehasher).Union();
15422	}
15423	case SparseIndexVector_Uint8Vector: {
15424	auto ptr = reinterpret_cast<const tflite::Uint8VectorT *>(value);
15425	return CreateUint8Vector(_fbb, ptr, _rehasher).Union();
15426	}
15427	default: return `0`;
15428	}
15429	}
15430
15431	inline SparseIndexVectorUnion::SparseIndexVectorUnion(const SparseIndexVectorUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
15432	switch (type) {
15433	case SparseIndexVector_Int32Vector: {
15434	value = new tflite::Int32VectorT (*reinterpret_cast<tflite::Int32VectorT *>(u.value));
15435	break;
15436	}
15437	case SparseIndexVector_Uint16Vector: {
15438	value = new tflite::Uint16VectorT (*reinterpret_cast<tflite::Uint16VectorT *>(u.value));
15439	break;
15440	}
15441	case SparseIndexVector_Uint8Vector: {
15442	value = new tflite::Uint8VectorT (*reinterpret_cast<tflite::Uint8VectorT *>(u.value));
15443	break;
15444	}
15445	default:
15446	break;
15447	}
15448	}
15449
15450	inline void SparseIndexVectorUnion::Reset() {
15451	switch (type) {
15452	case SparseIndexVector_Int32Vector: {
15453	auto ptr = reinterpret_cast<tflite::Int32VectorT *>(value);
15454	delete ptr;
15455	break;
15456	}
15457	case SparseIndexVector_Uint16Vector: {
15458	auto ptr = reinterpret_cast<tflite::Uint16VectorT *>(value);
15459	delete ptr;
15460	break;
15461	}
15462	case SparseIndexVector_Uint8Vector: {
15463	auto ptr = reinterpret_cast<tflite::Uint8VectorT *>(value);
15464	delete ptr;
15465	break;
15466	}
15467	default: break;
15468	}
15469	value = nullptr;
15470	type = SparseIndexVector_NONE;
15471	}
15472
15473	inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
15474	switch (type) {
15475	case BuiltinOptions_NONE: {
15476	return true;
15477	}
15478	case BuiltinOptions_Conv2DOptions: {
15479	auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
15480	return verifier.VerifyTable(ptr);
15481	}
15482	case BuiltinOptions_DepthwiseConv2DOptions: {
15483	auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
15484	return verifier.VerifyTable(ptr);
15485	}
15486	case BuiltinOptions_ConcatEmbeddingsOptions: {
15487	auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
15488	return verifier.VerifyTable(ptr);
15489	}
15490	case BuiltinOptions_LSHProjectionOptions: {
15491	auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
15492	return verifier.VerifyTable(ptr);
15493	}
15494	case BuiltinOptions_Pool2DOptions: {
15495	auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
15496	return verifier.VerifyTable(ptr);
15497	}
15498	case BuiltinOptions_SVDFOptions: {
15499	auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
15500	return verifier.VerifyTable(ptr);
15501	}
15502	case BuiltinOptions_RNNOptions: {
15503	auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
15504	return verifier.VerifyTable(ptr);
15505	}
15506	case BuiltinOptions_FullyConnectedOptions: {
15507	auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
15508	return verifier.VerifyTable(ptr);
15509	}
15510	case BuiltinOptions_SoftmaxOptions: {
15511	auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
15512	return verifier.VerifyTable(ptr);
15513	}
15514	case BuiltinOptions_ConcatenationOptions: {
15515	auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
15516	return verifier.VerifyTable(ptr);
15517	}
15518	case BuiltinOptions_AddOptions: {
15519	auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
15520	return verifier.VerifyTable(ptr);
15521	}
15522	case BuiltinOptions_L2NormOptions: {
15523	auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
15524	return verifier.VerifyTable(ptr);
15525	}
15526	case BuiltinOptions_LocalResponseNormalizationOptions: {
15527	auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
15528	return verifier.VerifyTable(ptr);
15529	}
15530	case BuiltinOptions_LSTMOptions: {
15531	auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
15532	return verifier.VerifyTable(ptr);
15533	}
15534	case BuiltinOptions_ResizeBilinearOptions: {
15535	auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
15536	return verifier.VerifyTable(ptr);
15537	}
15538	case BuiltinOptions_CallOptions: {
15539	auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
15540	return verifier.VerifyTable(ptr);
15541	}
15542	case BuiltinOptions_ReshapeOptions: {
15543	auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
15544	return verifier.VerifyTable(ptr);
15545	}
15546	case BuiltinOptions_SkipGramOptions: {
15547	auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
15548	return verifier.VerifyTable(ptr);
15549	}
15550	case BuiltinOptions_SpaceToDepthOptions: {
15551	auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
15552	return verifier.VerifyTable(ptr);
15553	}
15554	case BuiltinOptions_EmbeddingLookupSparseOptions: {
15555	auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
15556	return verifier.VerifyTable(ptr);
15557	}
15558	case BuiltinOptions_MulOptions: {
15559	auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
15560	return verifier.VerifyTable(ptr);
15561	}
15562	case BuiltinOptions_PadOptions: {
15563	auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
15564	return verifier.VerifyTable(ptr);
15565	}
15566	case BuiltinOptions_GatherOptions: {
15567	auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
15568	return verifier.VerifyTable(ptr);
15569	}
15570	case BuiltinOptions_BatchToSpaceNDOptions: {
15571	auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
15572	return verifier.VerifyTable(ptr);
15573	}
15574	case BuiltinOptions_SpaceToBatchNDOptions: {
15575	auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
15576	return verifier.VerifyTable(ptr);
15577	}
15578	case BuiltinOptions_TransposeOptions: {
15579	auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
15580	return verifier.VerifyTable(ptr);
15581	}
15582	case BuiltinOptions_ReducerOptions: {
15583	auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
15584	return verifier.VerifyTable(ptr);
15585	}
15586	case BuiltinOptions_SubOptions: {
15587	auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
15588	return verifier.VerifyTable(ptr);
15589	}
15590	case BuiltinOptions_DivOptions: {
15591	auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
15592	return verifier.VerifyTable(ptr);
15593	}
15594	case BuiltinOptions_SqueezeOptions: {
15595	auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
15596	return verifier.VerifyTable(ptr);
15597	}
15598	case BuiltinOptions_SequenceRNNOptions: {
15599	auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
15600	return verifier.VerifyTable(ptr);
15601	}
15602	case BuiltinOptions_StridedSliceOptions: {
15603	auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
15604	return verifier.VerifyTable(ptr);
15605	}
15606	case BuiltinOptions_ExpOptions: {
15607	auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
15608	return verifier.VerifyTable(ptr);
15609	}
15610	case BuiltinOptions_TopKV2Options: {
15611	auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
15612	return verifier.VerifyTable(ptr);
15613	}
15614	case BuiltinOptions_SplitOptions: {
15615	auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
15616	return verifier.VerifyTable(ptr);
15617	}
15618	case BuiltinOptions_LogSoftmaxOptions: {
15619	auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
15620	return verifier.VerifyTable(ptr);
15621	}
15622	case BuiltinOptions_CastOptions: {
15623	auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
15624	return verifier.VerifyTable(ptr);
15625	}
15626	case BuiltinOptions_DequantizeOptions: {
15627	auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
15628	return verifier.VerifyTable(ptr);
15629	}
15630	case BuiltinOptions_MaximumMinimumOptions: {
15631	auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
15632	return verifier.VerifyTable(ptr);
15633	}
15634	case BuiltinOptions_ArgMaxOptions: {
15635	auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
15636	return verifier.VerifyTable(ptr);
15637	}
15638	case BuiltinOptions_LessOptions: {
15639	auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
15640	return verifier.VerifyTable(ptr);
15641	}
15642	case BuiltinOptions_NegOptions: {
15643	auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
15644	return verifier.VerifyTable(ptr);
15645	}
15646	case BuiltinOptions_PadV2Options: {
15647	auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
15648	return verifier.VerifyTable(ptr);
15649	}
15650	case BuiltinOptions_GreaterOptions: {
15651	auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
15652	return verifier.VerifyTable(ptr);
15653	}
15654	case BuiltinOptions_GreaterEqualOptions: {
15655	auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
15656	return verifier.VerifyTable(ptr);
15657	}
15658	case BuiltinOptions_LessEqualOptions: {
15659	auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
15660	return verifier.VerifyTable(ptr);
15661	}
15662	case BuiltinOptions_SelectOptions: {
15663	auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
15664	return verifier.VerifyTable(ptr);
15665	}
15666	case BuiltinOptions_SliceOptions: {
15667	auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
15668	return verifier.VerifyTable(ptr);
15669	}
15670	case BuiltinOptions_TransposeConvOptions: {
15671	auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
15672	return verifier.VerifyTable(ptr);
15673	}
15674	case BuiltinOptions_SparseToDenseOptions: {
15675	auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
15676	return verifier.VerifyTable(ptr);
15677	}
15678	case BuiltinOptions_TileOptions: {
15679	auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
15680	return verifier.VerifyTable(ptr);
15681	}
15682	case BuiltinOptions_ExpandDimsOptions: {
15683	auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
15684	return verifier.VerifyTable(ptr);
15685	}
15686	case BuiltinOptions_EqualOptions: {
15687	auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
15688	return verifier.VerifyTable(ptr);
15689	}
15690	case BuiltinOptions_NotEqualOptions: {
15691	auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
15692	return verifier.VerifyTable(ptr);
15693	}
15694	case BuiltinOptions_ShapeOptions: {
15695	auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
15696	return verifier.VerifyTable(ptr);
15697	}
15698	case BuiltinOptions_PowOptions: {
15699	auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
15700	return verifier.VerifyTable(ptr);
15701	}
15702	case BuiltinOptions_ArgMinOptions: {
15703	auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
15704	return verifier.VerifyTable(ptr);
15705	}
15706	case BuiltinOptions_FakeQuantOptions: {
15707	auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
15708	return verifier.VerifyTable(ptr);
15709	}
15710	case BuiltinOptions_PackOptions: {
15711	auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
15712	return verifier.VerifyTable(ptr);
15713	}
15714	case BuiltinOptions_LogicalOrOptions: {
15715	auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
15716	return verifier.VerifyTable(ptr);
15717	}
15718	case BuiltinOptions_OneHotOptions: {
15719	auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
15720	return verifier.VerifyTable(ptr);
15721	}
15722	case BuiltinOptions_LogicalAndOptions: {
15723	auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
15724	return verifier.VerifyTable(ptr);
15725	}
15726	case BuiltinOptions_LogicalNotOptions: {
15727	auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
15728	return verifier.VerifyTable(ptr);
15729	}
15730	case BuiltinOptions_UnpackOptions: {
15731	auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
15732	return verifier.VerifyTable(ptr);
15733	}
15734	case BuiltinOptions_FloorDivOptions: {
15735	auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
15736	return verifier.VerifyTable(ptr);
15737	}
15738	case BuiltinOptions_SquareOptions: {
15739	auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
15740	return verifier.VerifyTable(ptr);
15741	}
15742	case BuiltinOptions_ZerosLikeOptions: {
15743	auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
15744	return verifier.VerifyTable(ptr);
15745	}
15746	case BuiltinOptions_FillOptions: {
15747	auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
15748	return verifier.VerifyTable(ptr);
15749	}
15750	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
15751	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
15752	return verifier.VerifyTable(ptr);
15753	}
15754	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
15755	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
15756	return verifier.VerifyTable(ptr);
15757	}
15758	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
15759	auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
15760	return verifier.VerifyTable(ptr);
15761	}
15762	case BuiltinOptions_FloorModOptions: {
15763	auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
15764	return verifier.VerifyTable(ptr);
15765	}
15766	case BuiltinOptions_RangeOptions: {
15767	auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
15768	return verifier.VerifyTable(ptr);
15769	}
15770	case BuiltinOptions_ResizeNearestNeighborOptions: {
15771	auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
15772	return verifier.VerifyTable(ptr);
15773	}
15774	case BuiltinOptions_LeakyReluOptions: {
15775	auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
15776	return verifier.VerifyTable(ptr);
15777	}
15778	case BuiltinOptions_SquaredDifferenceOptions: {
15779	auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
15780	return verifier.VerifyTable(ptr);
15781	}
15782	case BuiltinOptions_MirrorPadOptions: {
15783	auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
15784	return verifier.VerifyTable(ptr);
15785	}
15786	case BuiltinOptions_AbsOptions: {
15787	auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
15788	return verifier.VerifyTable(ptr);
15789	}
15790	case BuiltinOptions_SplitVOptions: {
15791	auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
15792	return verifier.VerifyTable(ptr);
15793	}
15794	case BuiltinOptions_UniqueOptions: {
15795	auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
15796	return verifier.VerifyTable(ptr);
15797	}
15798	case BuiltinOptions_ReverseV2Options: {
15799	auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
15800	return verifier.VerifyTable(ptr);
15801	}
15802	case BuiltinOptions_AddNOptions: {
15803	auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
15804	return verifier.VerifyTable(ptr);
15805	}
15806	case BuiltinOptions_GatherNdOptions: {
15807	auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
15808	return verifier.VerifyTable(ptr);
15809	}
15810	case BuiltinOptions_CosOptions: {
15811	auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
15812	return verifier.VerifyTable(ptr);
15813	}
15814	case BuiltinOptions_WhereOptions: {
15815	auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
15816	return verifier.VerifyTable(ptr);
15817	}
15818	case BuiltinOptions_RankOptions: {
15819	auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
15820	return verifier.VerifyTable(ptr);
15821	}
15822	case BuiltinOptions_ReverseSequenceOptions: {
15823	auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
15824	return verifier.VerifyTable(ptr);
15825	}
15826	case BuiltinOptions_MatrixDiagOptions: {
15827	auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
15828	return verifier.VerifyTable(ptr);
15829	}
15830	case BuiltinOptions_QuantizeOptions: {
15831	auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
15832	return verifier.VerifyTable(ptr);
15833	}
15834	case BuiltinOptions_MatrixSetDiagOptions: {
15835	auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
15836	return verifier.VerifyTable(ptr);
15837	}
15838	case BuiltinOptions_HardSwishOptions: {
15839	auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
15840	return verifier.VerifyTable(ptr);
15841	}
15842	case BuiltinOptions_IfOptions: {
15843	auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
15844	return verifier.VerifyTable(ptr);
15845	}
15846	case BuiltinOptions_WhileOptions: {
15847	auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
15848	return verifier.VerifyTable(ptr);
15849	}
15850	case BuiltinOptions_DepthToSpaceOptions: {
15851	auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
15852	return verifier.VerifyTable(ptr);
15853	}
15854	case BuiltinOptions_NonMaxSuppressionV4Options: {
15855	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
15856	return verifier.VerifyTable(ptr);
15857	}
15858	case BuiltinOptions_NonMaxSuppressionV5Options: {
15859	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
15860	return verifier.VerifyTable(ptr);
15861	}
15862	case BuiltinOptions_ScatterNdOptions: {
15863	auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
15864	return verifier.VerifyTable(ptr);
15865	}
15866	case BuiltinOptions_SelectV2Options: {
15867	auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
15868	return verifier.VerifyTable(ptr);
15869	}
15870	case BuiltinOptions_DensifyOptions: {
15871	auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
15872	return verifier.VerifyTable(ptr);
15873	}
15874	case BuiltinOptions_SegmentSumOptions: {
15875	auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
15876	return verifier.VerifyTable(ptr);
15877	}
15878	case BuiltinOptions_BatchMatMulOptions: {
15879	auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
15880	return verifier.VerifyTable(ptr);
15881	}
15882	case BuiltinOptions_CumsumOptions: {
15883	auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
15884	return verifier.VerifyTable(ptr);
15885	}
15886	case BuiltinOptions_CallOnceOptions: {
15887	auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
15888	return verifier.VerifyTable(ptr);
15889	}
15890	case BuiltinOptions_BroadcastToOptions: {
15891	auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
15892	return verifier.VerifyTable(ptr);
15893	}
15894	case BuiltinOptions_Rfft2dOptions: {
15895	auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
15896	return verifier.VerifyTable(ptr);
15897	}
15898	case BuiltinOptions_Conv3DOptions: {
15899	auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
15900	return verifier.VerifyTable(ptr);
15901	}
15902	case BuiltinOptions_HashtableOptions: {
15903	auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
15904	return verifier.VerifyTable(ptr);
15905	}
15906	case BuiltinOptions_HashtableFindOptions: {
15907	auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
15908	return verifier.VerifyTable(ptr);
15909	}
15910	case BuiltinOptions_HashtableImportOptions: {
15911	auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
15912	return verifier.VerifyTable(ptr);
15913	}
15914	case BuiltinOptions_HashtableSizeOptions: {
15915	auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
15916	return verifier.VerifyTable(ptr);
15917	}
15918	default: return true;
15919	}
15920	}
15921
15922	inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types) {
15923	if (!values \|\| !types) return !values && !types;
15924	if (values->size() != types->size()) return false;
15925	for (flatbuffers::uoffset_t i = `0`; i < values->size(); ++i) {
15926	if (!VerifyBuiltinOptions(
15927	verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
15928	return false;
15929	}
15930	}
15931	return true;
15932	}
15933
15934	inline void BuiltinOptionsUnion::UnPack(const* void obj, BuiltinOptions type, const* flatbuffers::resolver_function_t *resolver) {
15935	switch (type) {
15936	case BuiltinOptions_Conv2DOptions: {
15937	auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
15938	return ptr->UnPack(resolver);
15939	}
15940	case BuiltinOptions_DepthwiseConv2DOptions: {
15941	auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
15942	return ptr->UnPack(resolver);
15943	}
15944	case BuiltinOptions_ConcatEmbeddingsOptions: {
15945	auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
15946	return ptr->UnPack(resolver);
15947	}
15948	case BuiltinOptions_LSHProjectionOptions: {
15949	auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
15950	return ptr->UnPack(resolver);
15951	}
15952	case BuiltinOptions_Pool2DOptions: {
15953	auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
15954	return ptr->UnPack(resolver);
15955	}
15956	case BuiltinOptions_SVDFOptions: {
15957	auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
15958	return ptr->UnPack(resolver);
15959	}
15960	case BuiltinOptions_RNNOptions: {
15961	auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
15962	return ptr->UnPack(resolver);
15963	}
15964	case BuiltinOptions_FullyConnectedOptions: {
15965	auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
15966	return ptr->UnPack(resolver);
15967	}
15968	case BuiltinOptions_SoftmaxOptions: {
15969	auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
15970	return ptr->UnPack(resolver);
15971	}
15972	case BuiltinOptions_ConcatenationOptions: {
15973	auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
15974	return ptr->UnPack(resolver);
15975	}
15976	case BuiltinOptions_AddOptions: {
15977	auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
15978	return ptr->UnPack(resolver);
15979	}
15980	case BuiltinOptions_L2NormOptions: {
15981	auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
15982	return ptr->UnPack(resolver);
15983	}
15984	case BuiltinOptions_LocalResponseNormalizationOptions: {
15985	auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
15986	return ptr->UnPack(resolver);
15987	}
15988	case BuiltinOptions_LSTMOptions: {
15989	auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
15990	return ptr->UnPack(resolver);
15991	}
15992	case BuiltinOptions_ResizeBilinearOptions: {
15993	auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
15994	return ptr->UnPack(resolver);
15995	}
15996	case BuiltinOptions_CallOptions: {
15997	auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
15998	return ptr->UnPack(resolver);
15999	}
16000	case BuiltinOptions_ReshapeOptions: {
16001	auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
16002	return ptr->UnPack(resolver);
16003	}
16004	case BuiltinOptions_SkipGramOptions: {
16005	auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
16006	return ptr->UnPack(resolver);
16007	}
16008	case BuiltinOptions_SpaceToDepthOptions: {
16009	auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
16010	return ptr->UnPack(resolver);
16011	}
16012	case BuiltinOptions_EmbeddingLookupSparseOptions: {
16013	auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
16014	return ptr->UnPack(resolver);
16015	}
16016	case BuiltinOptions_MulOptions: {
16017	auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
16018	return ptr->UnPack(resolver);
16019	}
16020	case BuiltinOptions_PadOptions: {
16021	auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
16022	return ptr->UnPack(resolver);
16023	}
16024	case BuiltinOptions_GatherOptions: {
16025	auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
16026	return ptr->UnPack(resolver);
16027	}
16028	case BuiltinOptions_BatchToSpaceNDOptions: {
16029	auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
16030	return ptr->UnPack(resolver);
16031	}
16032	case BuiltinOptions_SpaceToBatchNDOptions: {
16033	auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
16034	return ptr->UnPack(resolver);
16035	}
16036	case BuiltinOptions_TransposeOptions: {
16037	auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
16038	return ptr->UnPack(resolver);
16039	}
16040	case BuiltinOptions_ReducerOptions: {
16041	auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
16042	return ptr->UnPack(resolver);
16043	}
16044	case BuiltinOptions_SubOptions: {
16045	auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
16046	return ptr->UnPack(resolver);
16047	}
16048	case BuiltinOptions_DivOptions: {
16049	auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
16050	return ptr->UnPack(resolver);
16051	}
16052	case BuiltinOptions_SqueezeOptions: {
16053	auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
16054	return ptr->UnPack(resolver);
16055	}
16056	case BuiltinOptions_SequenceRNNOptions: {
16057	auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
16058	return ptr->UnPack(resolver);
16059	}
16060	case BuiltinOptions_StridedSliceOptions: {
16061	auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
16062	return ptr->UnPack(resolver);
16063	}
16064	case BuiltinOptions_ExpOptions: {
16065	auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
16066	return ptr->UnPack(resolver);
16067	}
16068	case BuiltinOptions_TopKV2Options: {
16069	auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
16070	return ptr->UnPack(resolver);
16071	}
16072	case BuiltinOptions_SplitOptions: {
16073	auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
16074	return ptr->UnPack(resolver);
16075	}
16076	case BuiltinOptions_LogSoftmaxOptions: {
16077	auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
16078	return ptr->UnPack(resolver);
16079	}
16080	case BuiltinOptions_CastOptions: {
16081	auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
16082	return ptr->UnPack(resolver);
16083	}
16084	case BuiltinOptions_DequantizeOptions: {
16085	auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
16086	return ptr->UnPack(resolver);
16087	}
16088	case BuiltinOptions_MaximumMinimumOptions: {
16089	auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
16090	return ptr->UnPack(resolver);
16091	}
16092	case BuiltinOptions_ArgMaxOptions: {
16093	auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
16094	return ptr->UnPack(resolver);
16095	}
16096	case BuiltinOptions_LessOptions: {
16097	auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
16098	return ptr->UnPack(resolver);
16099	}
16100	case BuiltinOptions_NegOptions: {
16101	auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
16102	return ptr->UnPack(resolver);
16103	}
16104	case BuiltinOptions_PadV2Options: {
16105	auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
16106	return ptr->UnPack(resolver);
16107	}
16108	case BuiltinOptions_GreaterOptions: {
16109	auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
16110	return ptr->UnPack(resolver);
16111	}
16112	case BuiltinOptions_GreaterEqualOptions: {
16113	auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
16114	return ptr->UnPack(resolver);
16115	}
16116	case BuiltinOptions_LessEqualOptions: {
16117	auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
16118	return ptr->UnPack(resolver);
16119	}
16120	case BuiltinOptions_SelectOptions: {
16121	auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
16122	return ptr->UnPack(resolver);
16123	}
16124	case BuiltinOptions_SliceOptions: {
16125	auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
16126	return ptr->UnPack(resolver);
16127	}
16128	case BuiltinOptions_TransposeConvOptions: {
16129	auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
16130	return ptr->UnPack(resolver);
16131	}
16132	case BuiltinOptions_SparseToDenseOptions: {
16133	auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
16134	return ptr->UnPack(resolver);
16135	}
16136	case BuiltinOptions_TileOptions: {
16137	auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
16138	return ptr->UnPack(resolver);
16139	}
16140	case BuiltinOptions_ExpandDimsOptions: {
16141	auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
16142	return ptr->UnPack(resolver);
16143	}
16144	case BuiltinOptions_EqualOptions: {
16145	auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
16146	return ptr->UnPack(resolver);
16147	}
16148	case BuiltinOptions_NotEqualOptions: {
16149	auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
16150	return ptr->UnPack(resolver);
16151	}
16152	case BuiltinOptions_ShapeOptions: {
16153	auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
16154	return ptr->UnPack(resolver);
16155	}
16156	case BuiltinOptions_PowOptions: {
16157	auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
16158	return ptr->UnPack(resolver);
16159	}
16160	case BuiltinOptions_ArgMinOptions: {
16161	auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
16162	return ptr->UnPack(resolver);
16163	}
16164	case BuiltinOptions_FakeQuantOptions: {
16165	auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
16166	return ptr->UnPack(resolver);
16167	}
16168	case BuiltinOptions_PackOptions: {
16169	auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
16170	return ptr->UnPack(resolver);
16171	}
16172	case BuiltinOptions_LogicalOrOptions: {
16173	auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
16174	return ptr->UnPack(resolver);
16175	}
16176	case BuiltinOptions_OneHotOptions: {
16177	auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
16178	return ptr->UnPack(resolver);
16179	}
16180	case BuiltinOptions_LogicalAndOptions: {
16181	auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
16182	return ptr->UnPack(resolver);
16183	}
16184	case BuiltinOptions_LogicalNotOptions: {
16185	auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
16186	return ptr->UnPack(resolver);
16187	}
16188	case BuiltinOptions_UnpackOptions: {
16189	auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
16190	return ptr->UnPack(resolver);
16191	}
16192	case BuiltinOptions_FloorDivOptions: {
16193	auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
16194	return ptr->UnPack(resolver);
16195	}
16196	case BuiltinOptions_SquareOptions: {
16197	auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
16198	return ptr->UnPack(resolver);
16199	}
16200	case BuiltinOptions_ZerosLikeOptions: {
16201	auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
16202	return ptr->UnPack(resolver);
16203	}
16204	case BuiltinOptions_FillOptions: {
16205	auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
16206	return ptr->UnPack(resolver);
16207	}
16208	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
16209	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
16210	return ptr->UnPack(resolver);
16211	}
16212	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
16213	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
16214	return ptr->UnPack(resolver);
16215	}
16216	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
16217	auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
16218	return ptr->UnPack(resolver);
16219	}
16220	case BuiltinOptions_FloorModOptions: {
16221	auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
16222	return ptr->UnPack(resolver);
16223	}
16224	case BuiltinOptions_RangeOptions: {
16225	auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
16226	return ptr->UnPack(resolver);
16227	}
16228	case BuiltinOptions_ResizeNearestNeighborOptions: {
16229	auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
16230	return ptr->UnPack(resolver);
16231	}
16232	case BuiltinOptions_LeakyReluOptions: {
16233	auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
16234	return ptr->UnPack(resolver);
16235	}
16236	case BuiltinOptions_SquaredDifferenceOptions: {
16237	auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
16238	return ptr->UnPack(resolver);
16239	}
16240	case BuiltinOptions_MirrorPadOptions: {
16241	auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
16242	return ptr->UnPack(resolver);
16243	}
16244	case BuiltinOptions_AbsOptions: {
16245	auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
16246	return ptr->UnPack(resolver);
16247	}
16248	case BuiltinOptions_SplitVOptions: {
16249	auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
16250	return ptr->UnPack(resolver);
16251	}
16252	case BuiltinOptions_UniqueOptions: {
16253	auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
16254	return ptr->UnPack(resolver);
16255	}
16256	case BuiltinOptions_ReverseV2Options: {
16257	auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
16258	return ptr->UnPack(resolver);
16259	}
16260	case BuiltinOptions_AddNOptions: {
16261	auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
16262	return ptr->UnPack(resolver);
16263	}
16264	case BuiltinOptions_GatherNdOptions: {
16265	auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
16266	return ptr->UnPack(resolver);
16267	}
16268	case BuiltinOptions_CosOptions: {
16269	auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
16270	return ptr->UnPack(resolver);
16271	}
16272	case BuiltinOptions_WhereOptions: {
16273	auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
16274	return ptr->UnPack(resolver);
16275	}
16276	case BuiltinOptions_RankOptions: {
16277	auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
16278	return ptr->UnPack(resolver);
16279	}
16280	case BuiltinOptions_ReverseSequenceOptions: {
16281	auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
16282	return ptr->UnPack(resolver);
16283	}
16284	case BuiltinOptions_MatrixDiagOptions: {
16285	auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
16286	return ptr->UnPack(resolver);
16287	}
16288	case BuiltinOptions_QuantizeOptions: {
16289	auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
16290	return ptr->UnPack(resolver);
16291	}
16292	case BuiltinOptions_MatrixSetDiagOptions: {
16293	auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
16294	return ptr->UnPack(resolver);
16295	}
16296	case BuiltinOptions_HardSwishOptions: {
16297	auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
16298	return ptr->UnPack(resolver);
16299	}
16300	case BuiltinOptions_IfOptions: {
16301	auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
16302	return ptr->UnPack(resolver);
16303	}
16304	case BuiltinOptions_WhileOptions: {
16305	auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
16306	return ptr->UnPack(resolver);
16307	}
16308	case BuiltinOptions_DepthToSpaceOptions: {
16309	auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
16310	return ptr->UnPack(resolver);
16311	}
16312	case BuiltinOptions_NonMaxSuppressionV4Options: {
16313	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
16314	return ptr->UnPack(resolver);
16315	}
16316	case BuiltinOptions_NonMaxSuppressionV5Options: {
16317	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
16318	return ptr->UnPack(resolver);
16319	}
16320	case BuiltinOptions_ScatterNdOptions: {
16321	auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
16322	return ptr->UnPack(resolver);
16323	}
16324	case BuiltinOptions_SelectV2Options: {
16325	auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
16326	return ptr->UnPack(resolver);
16327	}
16328	case BuiltinOptions_DensifyOptions: {
16329	auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
16330	return ptr->UnPack(resolver);
16331	}
16332	case BuiltinOptions_SegmentSumOptions: {
16333	auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
16334	return ptr->UnPack(resolver);
16335	}
16336	case BuiltinOptions_BatchMatMulOptions: {
16337	auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
16338	return ptr->UnPack(resolver);
16339	}
16340	case BuiltinOptions_CumsumOptions: {
16341	auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
16342	return ptr->UnPack(resolver);
16343	}
16344	case BuiltinOptions_CallOnceOptions: {
16345	auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
16346	return ptr->UnPack(resolver);
16347	}
16348	case BuiltinOptions_BroadcastToOptions: {
16349	auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
16350	return ptr->UnPack(resolver);
16351	}
16352	case BuiltinOptions_Rfft2dOptions: {
16353	auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
16354	return ptr->UnPack(resolver);
16355	}
16356	case BuiltinOptions_Conv3DOptions: {
16357	auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
16358	return ptr->UnPack(resolver);
16359	}
16360	case BuiltinOptions_HashtableOptions: {
16361	auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
16362	return ptr->UnPack(resolver);
16363	}
16364	case BuiltinOptions_HashtableFindOptions: {
16365	auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
16366	return ptr->UnPack(resolver);
16367	}
16368	case BuiltinOptions_HashtableImportOptions: {
16369	auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
16370	return ptr->UnPack(resolver);
16371	}
16372	case BuiltinOptions_HashtableSizeOptions: {
16373	auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
16374	return ptr->UnPack(resolver);
16375	}
16376	default: return nullptr;
16377	}
16378	}
16379
16380	inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher) const* {
16381	switch (type) {
16382	case BuiltinOptions_Conv2DOptions: {
16383	auto ptr = reinterpret_cast<const tflite::Conv2DOptionsT *>(value);
16384	return CreateConv2DOptions(_fbb, ptr, _rehasher).Union();
16385	}
16386	case BuiltinOptions_DepthwiseConv2DOptions: {
16387	auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptionsT *>(value);
16388	return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union();
16389	}
16390	case BuiltinOptions_ConcatEmbeddingsOptions: {
16391	auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT *>(value);
16392	return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union();
16393	}
16394	case BuiltinOptions_LSHProjectionOptions: {
16395	auto ptr = reinterpret_cast<const tflite::LSHProjectionOptionsT *>(value);
16396	return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union();
16397	}
16398	case BuiltinOptions_Pool2DOptions: {
16399	auto ptr = reinterpret_cast<const tflite::Pool2DOptionsT *>(value);
16400	return CreatePool2DOptions(_fbb, ptr, _rehasher).Union();
16401	}
16402	case BuiltinOptions_SVDFOptions: {
16403	auto ptr = reinterpret_cast<const tflite::SVDFOptionsT *>(value);
16404	return CreateSVDFOptions(_fbb, ptr, _rehasher).Union();
16405	}
16406	case BuiltinOptions_RNNOptions: {
16407	auto ptr = reinterpret_cast<const tflite::RNNOptionsT *>(value);
16408	return CreateRNNOptions(_fbb, ptr, _rehasher).Union();
16409	}
16410	case BuiltinOptions_FullyConnectedOptions: {
16411	auto ptr = reinterpret_cast<const tflite::FullyConnectedOptionsT *>(value);
16412	return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
16413	}
16414	case BuiltinOptions_SoftmaxOptions: {
16415	auto ptr = reinterpret_cast<const tflite::SoftmaxOptionsT *>(value);
16416	return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union();
16417	}
16418	case BuiltinOptions_ConcatenationOptions: {
16419	auto ptr = reinterpret_cast<const tflite::ConcatenationOptionsT *>(value);
16420	return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union();
16421	}
16422	case BuiltinOptions_AddOptions: {
16423	auto ptr = reinterpret_cast<const tflite::AddOptionsT *>(value);
16424	return CreateAddOptions(_fbb, ptr, _rehasher).Union();
16425	}
16426	case BuiltinOptions_L2NormOptions: {
16427	auto ptr = reinterpret_cast<const tflite::L2NormOptionsT *>(value);
16428	return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
16429	}
16430	case BuiltinOptions_LocalResponseNormalizationOptions: {
16431	auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT *>(value);
16432	return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
16433	}
16434	case BuiltinOptions_LSTMOptions: {
16435	auto ptr = reinterpret_cast<const tflite::LSTMOptionsT *>(value);
16436	return CreateLSTMOptions(_fbb, ptr, _rehasher).Union();
16437	}
16438	case BuiltinOptions_ResizeBilinearOptions: {
16439	auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptionsT *>(value);
16440	return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union();
16441	}
16442	case BuiltinOptions_CallOptions: {
16443	auto ptr = reinterpret_cast<const tflite::CallOptionsT *>(value);
16444	return CreateCallOptions(_fbb, ptr, _rehasher).Union();
16445	}
16446	case BuiltinOptions_ReshapeOptions: {
16447	auto ptr = reinterpret_cast<const tflite::ReshapeOptionsT *>(value);
16448	return CreateReshapeOptions(_fbb, ptr, _rehasher).Union();
16449	}
16450	case BuiltinOptions_SkipGramOptions: {
16451	auto ptr = reinterpret_cast<const tflite::SkipGramOptionsT *>(value);
16452	return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union();
16453	}
16454	case BuiltinOptions_SpaceToDepthOptions: {
16455	auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptionsT *>(value);
16456	return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union();
16457	}
16458	case BuiltinOptions_EmbeddingLookupSparseOptions: {
16459	auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT *>(value);
16460	return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union();
16461	}
16462	case BuiltinOptions_MulOptions: {
16463	auto ptr = reinterpret_cast<const tflite::MulOptionsT *>(value);
16464	return CreateMulOptions(_fbb, ptr, _rehasher).Union();
16465	}
16466	case BuiltinOptions_PadOptions: {
16467	auto ptr = reinterpret_cast<const tflite::PadOptionsT *>(value);
16468	return CreatePadOptions(_fbb, ptr, _rehasher).Union();
16469	}
16470	case BuiltinOptions_GatherOptions: {
16471	auto ptr = reinterpret_cast<const tflite::GatherOptionsT *>(value);
16472	return CreateGatherOptions(_fbb, ptr, _rehasher).Union();
16473	}
16474	case BuiltinOptions_BatchToSpaceNDOptions: {
16475	auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptionsT *>(value);
16476	return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union();
16477	}
16478	case BuiltinOptions_SpaceToBatchNDOptions: {
16479	auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptionsT *>(value);
16480	return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union();
16481	}
16482	case BuiltinOptions_TransposeOptions: {
16483	auto ptr = reinterpret_cast<const tflite::TransposeOptionsT *>(value);
16484	return CreateTransposeOptions(_fbb, ptr, _rehasher).Union();
16485	}
16486	case BuiltinOptions_ReducerOptions: {
16487	auto ptr = reinterpret_cast<const tflite::ReducerOptionsT *>(value);
16488	return CreateReducerOptions(_fbb, ptr, _rehasher).Union();
16489	}
16490	case BuiltinOptions_SubOptions: {
16491	auto ptr = reinterpret_cast<const tflite::SubOptionsT *>(value);
16492	return CreateSubOptions(_fbb, ptr, _rehasher).Union();
16493	}
16494	case BuiltinOptions_DivOptions: {
16495	auto ptr = reinterpret_cast<const tflite::DivOptionsT *>(value);
16496	return CreateDivOptions(_fbb, ptr, _rehasher).Union();
16497	}
16498	case BuiltinOptions_SqueezeOptions: {
16499	auto ptr = reinterpret_cast<const tflite::SqueezeOptionsT *>(value);
16500	return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union();
16501	}
16502	case BuiltinOptions_SequenceRNNOptions: {
16503	auto ptr = reinterpret_cast<const tflite::SequenceRNNOptionsT *>(value);
16504	return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
16505	}
16506	case BuiltinOptions_StridedSliceOptions: {
16507	auto ptr = reinterpret_cast<const tflite::StridedSliceOptionsT *>(value);
16508	return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
16509	}
16510	case BuiltinOptions_ExpOptions: {
16511	auto ptr = reinterpret_cast<const tflite::ExpOptionsT *>(value);
16512	return CreateExpOptions(_fbb, ptr, _rehasher).Union();
16513	}
16514	case BuiltinOptions_TopKV2Options: {
16515	auto ptr = reinterpret_cast<const tflite::TopKV2OptionsT *>(value);
16516	return CreateTopKV2Options(_fbb, ptr, _rehasher).Union();
16517	}
16518	case BuiltinOptions_SplitOptions: {
16519	auto ptr = reinterpret_cast<const tflite::SplitOptionsT *>(value);
16520	return CreateSplitOptions(_fbb, ptr, _rehasher).Union();
16521	}
16522	case BuiltinOptions_LogSoftmaxOptions: {
16523	auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptionsT *>(value);
16524	return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union();
16525	}
16526	case BuiltinOptions_CastOptions: {
16527	auto ptr = reinterpret_cast<const tflite::CastOptionsT *>(value);
16528	return CreateCastOptions(_fbb, ptr, _rehasher).Union();
16529	}
16530	case BuiltinOptions_DequantizeOptions: {
16531	auto ptr = reinterpret_cast<const tflite::DequantizeOptionsT *>(value);
16532	return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union();
16533	}
16534	case BuiltinOptions_MaximumMinimumOptions: {
16535	auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptionsT *>(value);
16536	return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union();
16537	}
16538	case BuiltinOptions_ArgMaxOptions: {
16539	auto ptr = reinterpret_cast<const tflite::ArgMaxOptionsT *>(value);
16540	return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union();
16541	}
16542	case BuiltinOptions_LessOptions: {
16543	auto ptr = reinterpret_cast<const tflite::LessOptionsT *>(value);
16544	return CreateLessOptions(_fbb, ptr, _rehasher).Union();
16545	}
16546	case BuiltinOptions_NegOptions: {
16547	auto ptr = reinterpret_cast<const tflite::NegOptionsT *>(value);
16548	return CreateNegOptions(_fbb, ptr, _rehasher).Union();
16549	}
16550	case BuiltinOptions_PadV2Options: {
16551	auto ptr = reinterpret_cast<const tflite::PadV2OptionsT *>(value);
16552	return CreatePadV2Options(_fbb, ptr, _rehasher).Union();
16553	}
16554	case BuiltinOptions_GreaterOptions: {
16555	auto ptr = reinterpret_cast<const tflite::GreaterOptionsT *>(value);
16556	return CreateGreaterOptions(_fbb, ptr, _rehasher).Union();
16557	}
16558	case BuiltinOptions_GreaterEqualOptions: {
16559	auto ptr = reinterpret_cast<const tflite::GreaterEqualOptionsT *>(value);
16560	return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union();
16561	}
16562	case BuiltinOptions_LessEqualOptions: {
16563	auto ptr = reinterpret_cast<const tflite::LessEqualOptionsT *>(value);
16564	return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union();
16565	}
16566	case BuiltinOptions_SelectOptions: {
16567	auto ptr = reinterpret_cast<const tflite::SelectOptionsT *>(value);
16568	return CreateSelectOptions(_fbb, ptr, _rehasher).Union();
16569	}
16570	case BuiltinOptions_SliceOptions: {
16571	auto ptr = reinterpret_cast<const tflite::SliceOptionsT *>(value);
16572	return CreateSliceOptions(_fbb, ptr, _rehasher).Union();
16573	}
16574	case BuiltinOptions_TransposeConvOptions: {
16575	auto ptr = reinterpret_cast<const tflite::TransposeConvOptionsT *>(value);
16576	return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union();
16577	}
16578	case BuiltinOptions_SparseToDenseOptions: {
16579	auto ptr = reinterpret_cast<const tflite::SparseToDenseOptionsT *>(value);
16580	return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union();
16581	}
16582	case BuiltinOptions_TileOptions: {
16583	auto ptr = reinterpret_cast<const tflite::TileOptionsT *>(value);
16584	return CreateTileOptions(_fbb, ptr, _rehasher).Union();
16585	}
16586	case BuiltinOptions_ExpandDimsOptions: {
16587	auto ptr = reinterpret_cast<const tflite::ExpandDimsOptionsT *>(value);
16588	return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union();
16589	}
16590	case BuiltinOptions_EqualOptions: {
16591	auto ptr = reinterpret_cast<const tflite::EqualOptionsT *>(value);
16592	return CreateEqualOptions(_fbb, ptr, _rehasher).Union();
16593	}
16594	case BuiltinOptions_NotEqualOptions: {
16595	auto ptr = reinterpret_cast<const tflite::NotEqualOptionsT *>(value);
16596	return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union();
16597	}
16598	case BuiltinOptions_ShapeOptions: {
16599	auto ptr = reinterpret_cast<const tflite::ShapeOptionsT *>(value);
16600	return CreateShapeOptions(_fbb, ptr, _rehasher).Union();
16601	}
16602	case BuiltinOptions_PowOptions: {
16603	auto ptr = reinterpret_cast<const tflite::PowOptionsT *>(value);
16604	return CreatePowOptions(_fbb, ptr, _rehasher).Union();
16605	}
16606	case BuiltinOptions_ArgMinOptions: {
16607	auto ptr = reinterpret_cast<const tflite::ArgMinOptionsT *>(value);
16608	return CreateArgMinOptions(_fbb, ptr, _rehasher).Union();
16609	}
16610	case BuiltinOptions_FakeQuantOptions: {
16611	auto ptr = reinterpret_cast<const tflite::FakeQuantOptionsT *>(value);
16612	return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union();
16613	}
16614	case BuiltinOptions_PackOptions: {
16615	auto ptr = reinterpret_cast<const tflite::PackOptionsT *>(value);
16616	return CreatePackOptions(_fbb, ptr, _rehasher).Union();
16617	}
16618	case BuiltinOptions_LogicalOrOptions: {
16619	auto ptr = reinterpret_cast<const tflite::LogicalOrOptionsT *>(value);
16620	return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union();
16621	}
16622	case BuiltinOptions_OneHotOptions: {
16623	auto ptr = reinterpret_cast<const tflite::OneHotOptionsT *>(value);
16624	return CreateOneHotOptions(_fbb, ptr, _rehasher).Union();
16625	}
16626	case BuiltinOptions_LogicalAndOptions: {
16627	auto ptr = reinterpret_cast<const tflite::LogicalAndOptionsT *>(value);
16628	return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union();
16629	}
16630	case BuiltinOptions_LogicalNotOptions: {
16631	auto ptr = reinterpret_cast<const tflite::LogicalNotOptionsT *>(value);
16632	return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union();
16633	}
16634	case BuiltinOptions_UnpackOptions: {
16635	auto ptr = reinterpret_cast<const tflite::UnpackOptionsT *>(value);
16636	return CreateUnpackOptions(_fbb, ptr, _rehasher).Union();
16637	}
16638	case BuiltinOptions_FloorDivOptions: {
16639	auto ptr = reinterpret_cast<const tflite::FloorDivOptionsT *>(value);
16640	return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union();
16641	}
16642	case BuiltinOptions_SquareOptions: {
16643	auto ptr = reinterpret_cast<const tflite::SquareOptionsT *>(value);
16644	return CreateSquareOptions(_fbb, ptr, _rehasher).Union();
16645	}
16646	case BuiltinOptions_ZerosLikeOptions: {
16647	auto ptr = reinterpret_cast<const tflite::ZerosLikeOptionsT *>(value);
16648	return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union();
16649	}
16650	case BuiltinOptions_FillOptions: {
16651	auto ptr = reinterpret_cast<const tflite::FillOptionsT *>(value);
16652	return CreateFillOptions(_fbb, ptr, _rehasher).Union();
16653	}
16654	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
16655	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT *>(value);
16656	return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
16657	}
16658	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
16659	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT *>(value);
16660	return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
16661	}
16662	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
16663	auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
16664	return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
16665	}
16666	case BuiltinOptions_FloorModOptions: {
16667	auto ptr = reinterpret_cast<const tflite::FloorModOptionsT *>(value);
16668	return CreateFloorModOptions(_fbb, ptr, _rehasher).Union();
16669	}
16670	case BuiltinOptions_RangeOptions: {
16671	auto ptr = reinterpret_cast<const tflite::RangeOptionsT *>(value);
16672	return CreateRangeOptions(_fbb, ptr, _rehasher).Union();
16673	}
16674	case BuiltinOptions_ResizeNearestNeighborOptions: {
16675	auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT *>(value);
16676	return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union();
16677	}
16678	case BuiltinOptions_LeakyReluOptions: {
16679	auto ptr = reinterpret_cast<const tflite::LeakyReluOptionsT *>(value);
16680	return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union();
16681	}
16682	case BuiltinOptions_SquaredDifferenceOptions: {
16683	auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptionsT *>(value);
16684	return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union();
16685	}
16686	case BuiltinOptions_MirrorPadOptions: {
16687	auto ptr = reinterpret_cast<const tflite::MirrorPadOptionsT *>(value);
16688	return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union();
16689	}
16690	case BuiltinOptions_AbsOptions: {
16691	auto ptr = reinterpret_cast<const tflite::AbsOptionsT *>(value);
16692	return CreateAbsOptions(_fbb, ptr, _rehasher).Union();
16693	}
16694	case BuiltinOptions_SplitVOptions: {
16695	auto ptr = reinterpret_cast<const tflite::SplitVOptionsT *>(value);
16696	return CreateSplitVOptions(_fbb, ptr, _rehasher).Union();
16697	}
16698	case BuiltinOptions_UniqueOptions: {
16699	auto ptr = reinterpret_cast<const tflite::UniqueOptionsT *>(value);
16700	return CreateUniqueOptions(_fbb, ptr, _rehasher).Union();
16701	}
16702	case BuiltinOptions_ReverseV2Options: {
16703	auto ptr = reinterpret_cast<const tflite::ReverseV2OptionsT *>(value);
16704	return CreateReverseV2Options(_fbb, ptr, _rehasher).Union();
16705	}
16706	case BuiltinOptions_AddNOptions: {
16707	auto ptr = reinterpret_cast<const tflite::AddNOptionsT *>(value);
16708	return CreateAddNOptions(_fbb, ptr, _rehasher).Union();
16709	}
16710	case BuiltinOptions_GatherNdOptions: {
16711	auto ptr = reinterpret_cast<const tflite::GatherNdOptionsT *>(value);
16712	return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union();
16713	}
16714	case BuiltinOptions_CosOptions: {
16715	auto ptr = reinterpret_cast<const tflite::CosOptionsT *>(value);
16716	return CreateCosOptions(_fbb, ptr, _rehasher).Union();
16717	}
16718	case BuiltinOptions_WhereOptions: {
16719	auto ptr = reinterpret_cast<const tflite::WhereOptionsT *>(value);
16720	return CreateWhereOptions(_fbb, ptr, _rehasher).Union();
16721	}
16722	case BuiltinOptions_RankOptions: {
16723	auto ptr = reinterpret_cast<const tflite::RankOptionsT *>(value);
16724	return CreateRankOptions(_fbb, ptr, _rehasher).Union();
16725	}
16726	case BuiltinOptions_ReverseSequenceOptions: {
16727	auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptionsT *>(value);
16728	return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union();
16729	}
16730	case BuiltinOptions_MatrixDiagOptions: {
16731	auto ptr = reinterpret_cast<const tflite::MatrixDiagOptionsT *>(value);
16732	return CreateMatrixDiagOptions(_fbb, ptr, _rehasher).Union();
16733	}
16734	case BuiltinOptions_QuantizeOptions: {
16735	auto ptr = reinterpret_cast<const tflite::QuantizeOptionsT *>(value);
16736	return CreateQuantizeOptions(_fbb, ptr, _rehasher).Union();
16737	}
16738	case BuiltinOptions_MatrixSetDiagOptions: {
16739	auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptionsT *>(value);
16740	return CreateMatrixSetDiagOptions(_fbb, ptr, _rehasher).Union();
16741	}
16742	case BuiltinOptions_HardSwishOptions: {
16743	auto ptr = reinterpret_cast<const tflite::HardSwishOptionsT *>(value);
16744	return CreateHardSwishOptions(_fbb, ptr, _rehasher).Union();
16745	}
16746	case BuiltinOptions_IfOptions: {
16747	auto ptr = reinterpret_cast<const tflite::IfOptionsT *>(value);
16748	return CreateIfOptions(_fbb, ptr, _rehasher).Union();
16749	}
16750	case BuiltinOptions_WhileOptions: {
16751	auto ptr = reinterpret_cast<const tflite::WhileOptionsT *>(value);
16752	return CreateWhileOptions(_fbb, ptr, _rehasher).Union();
16753	}
16754	case BuiltinOptions_DepthToSpaceOptions: {
16755	auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptionsT *>(value);
16756	return CreateDepthToSpaceOptions(_fbb, ptr, _rehasher).Union();
16757	}
16758	case BuiltinOptions_NonMaxSuppressionV4Options: {
16759	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT *>(value);
16760	return CreateNonMaxSuppressionV4Options(_fbb, ptr, _rehasher).Union();
16761	}
16762	case BuiltinOptions_NonMaxSuppressionV5Options: {
16763	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT *>(value);
16764	return CreateNonMaxSuppressionV5Options(_fbb, ptr, _rehasher).Union();
16765	}
16766	case BuiltinOptions_ScatterNdOptions: {
16767	auto ptr = reinterpret_cast<const tflite::ScatterNdOptionsT *>(value);
16768	return CreateScatterNdOptions(_fbb, ptr, _rehasher).Union();
16769	}
16770	case BuiltinOptions_SelectV2Options: {
16771	auto ptr = reinterpret_cast<const tflite::SelectV2OptionsT *>(value);
16772	return CreateSelectV2Options(_fbb, ptr, _rehasher).Union();
16773	}
16774	case BuiltinOptions_DensifyOptions: {
16775	auto ptr = reinterpret_cast<const tflite::DensifyOptionsT *>(value);
16776	return CreateDensifyOptions(_fbb, ptr, _rehasher).Union();
16777	}
16778	case BuiltinOptions_SegmentSumOptions: {
16779	auto ptr = reinterpret_cast<const tflite::SegmentSumOptionsT *>(value);
16780	return CreateSegmentSumOptions(_fbb, ptr, _rehasher).Union();
16781	}
16782	case BuiltinOptions_BatchMatMulOptions: {
16783	auto ptr = reinterpret_cast<const tflite::BatchMatMulOptionsT *>(value);
16784	return CreateBatchMatMulOptions(_fbb, ptr, _rehasher).Union();
16785	}
16786	case BuiltinOptions_CumsumOptions: {
16787	auto ptr = reinterpret_cast<const tflite::CumsumOptionsT *>(value);
16788	return CreateCumsumOptions(_fbb, ptr, _rehasher).Union();
16789	}
16790	case BuiltinOptions_CallOnceOptions: {
16791	auto ptr = reinterpret_cast<const tflite::CallOnceOptionsT *>(value);
16792	return CreateCallOnceOptions(_fbb, ptr, _rehasher).Union();
16793	}
16794	case BuiltinOptions_BroadcastToOptions: {
16795	auto ptr = reinterpret_cast<const tflite::BroadcastToOptionsT *>(value);
16796	return CreateBroadcastToOptions(_fbb, ptr, _rehasher).Union();
16797	}
16798	case BuiltinOptions_Rfft2dOptions: {
16799	auto ptr = reinterpret_cast<const tflite::Rfft2dOptionsT *>(value);
16800	return CreateRfft2dOptions(_fbb, ptr, _rehasher).Union();
16801	}
16802	case BuiltinOptions_Conv3DOptions: {
16803	auto ptr = reinterpret_cast<const tflite::Conv3DOptionsT *>(value);
16804	return CreateConv3DOptions(_fbb, ptr, _rehasher).Union();
16805	}
16806	case BuiltinOptions_HashtableOptions: {
16807	auto ptr = reinterpret_cast<const tflite::HashtableOptionsT *>(value);
16808	return CreateHashtableOptions(_fbb, ptr, _rehasher).Union();
16809	}
16810	case BuiltinOptions_HashtableFindOptions: {
16811	auto ptr = reinterpret_cast<const tflite::HashtableFindOptionsT *>(value);
16812	return CreateHashtableFindOptions(_fbb, ptr, _rehasher).Union();
16813	}
16814	case BuiltinOptions_HashtableImportOptions: {
16815	auto ptr = reinterpret_cast<const tflite::HashtableImportOptionsT *>(value);
16816	return CreateHashtableImportOptions(_fbb, ptr, _rehasher).Union();
16817	}
16818	case BuiltinOptions_HashtableSizeOptions: {
16819	auto ptr = reinterpret_cast<const tflite::HashtableSizeOptionsT *>(value);
16820	return CreateHashtableSizeOptions(_fbb, ptr, _rehasher).Union();
16821	}
16822	default: return `0`;
16823	}
16824	}
16825
16826	inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
16827	switch (type) {
16828	case BuiltinOptions_Conv2DOptions: {
16829	value = new tflite::Conv2DOptionsT (*reinterpret_cast<tflite::Conv2DOptionsT *>(u.value));
16830	break;
16831	}
16832	case BuiltinOptions_DepthwiseConv2DOptions: {
16833	value = new tflite::DepthwiseConv2DOptionsT (*reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(u.value));
16834	break;
16835	}
16836	case BuiltinOptions_ConcatEmbeddingsOptions: {
16837	value = new tflite::ConcatEmbeddingsOptionsT (*reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(u.value));
16838	break;
16839	}
16840	case BuiltinOptions_LSHProjectionOptions: {
16841	value = new tflite::LSHProjectionOptionsT (*reinterpret_cast<tflite::LSHProjectionOptionsT *>(u.value));
16842	break;
16843	}
16844	case BuiltinOptions_Pool2DOptions: {
16845	value = new tflite::Pool2DOptionsT (*reinterpret_cast<tflite::Pool2DOptionsT *>(u.value));
16846	break;
16847	}
16848	case BuiltinOptions_SVDFOptions: {
16849	value = new tflite::SVDFOptionsT (*reinterpret_cast<tflite::SVDFOptionsT *>(u.value));
16850	break;
16851	}
16852	case BuiltinOptions_RNNOptions: {
16853	value = new tflite::RNNOptionsT (*reinterpret_cast<tflite::RNNOptionsT *>(u.value));
16854	break;
16855	}
16856	case BuiltinOptions_FullyConnectedOptions: {
16857	value = new tflite::FullyConnectedOptionsT (*reinterpret_cast<tflite::FullyConnectedOptionsT *>(u.value));
16858	break;
16859	}
16860	case BuiltinOptions_SoftmaxOptions: {
16861	value = new tflite::SoftmaxOptionsT (*reinterpret_cast<tflite::SoftmaxOptionsT *>(u.value));
16862	break;
16863	}
16864	case BuiltinOptions_ConcatenationOptions: {
16865	value = new tflite::ConcatenationOptionsT (*reinterpret_cast<tflite::ConcatenationOptionsT *>(u.value));
16866	break;
16867	}
16868	case BuiltinOptions_AddOptions: {
16869	value = new tflite::AddOptionsT (*reinterpret_cast<tflite::AddOptionsT *>(u.value));
16870	break;
16871	}
16872	case BuiltinOptions_L2NormOptions: {
16873	value = new tflite::L2NormOptionsT (*reinterpret_cast<tflite::L2NormOptionsT *>(u.value));
16874	break;
16875	}
16876	case BuiltinOptions_LocalResponseNormalizationOptions: {
16877	value = new tflite::LocalResponseNormalizationOptionsT (*reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(u.value));
16878	break;
16879	}
16880	case BuiltinOptions_LSTMOptions: {
16881	value = new tflite::LSTMOptionsT (*reinterpret_cast<tflite::LSTMOptionsT *>(u.value));
16882	break;
16883	}
16884	case BuiltinOptions_ResizeBilinearOptions: {
16885	value = new tflite::ResizeBilinearOptionsT (*reinterpret_cast<tflite::ResizeBilinearOptionsT *>(u.value));
16886	break;
16887	}
16888	case BuiltinOptions_CallOptions: {
16889	value = new tflite::CallOptionsT (*reinterpret_cast<tflite::CallOptionsT *>(u.value));
16890	break;
16891	}
16892	case BuiltinOptions_ReshapeOptions: {
16893	value = new tflite::ReshapeOptionsT (*reinterpret_cast<tflite::ReshapeOptionsT *>(u.value));
16894	break;
16895	}
16896	case BuiltinOptions_SkipGramOptions: {
16897	value = new tflite::SkipGramOptionsT (*reinterpret_cast<tflite::SkipGramOptionsT *>(u.value));
16898	break;
16899	}
16900	case BuiltinOptions_SpaceToDepthOptions: {
16901	value = new tflite::SpaceToDepthOptionsT (*reinterpret_cast<tflite::SpaceToDepthOptionsT *>(u.value));
16902	break;
16903	}
16904	case BuiltinOptions_EmbeddingLookupSparseOptions: {
16905	value = new tflite::EmbeddingLookupSparseOptionsT (*reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(u.value));
16906	break;
16907	}
16908	case BuiltinOptions_MulOptions: {
16909	value = new tflite::MulOptionsT (*reinterpret_cast<tflite::MulOptionsT *>(u.value));
16910	break;
16911	}
16912	case BuiltinOptions_PadOptions: {
16913	value = new tflite::PadOptionsT (*reinterpret_cast<tflite::PadOptionsT *>(u.value));
16914	break;
16915	}
16916	case BuiltinOptions_GatherOptions: {
16917	value = new tflite::GatherOptionsT (*reinterpret_cast<tflite::GatherOptionsT *>(u.value));
16918	break;
16919	}
16920	case BuiltinOptions_BatchToSpaceNDOptions: {
16921	value = new tflite::BatchToSpaceNDOptionsT (*reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(u.value));
16922	break;
16923	}
16924	case BuiltinOptions_SpaceToBatchNDOptions: {
16925	value = new tflite::SpaceToBatchNDOptionsT (*reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(u.value));
16926	break;
16927	}
16928	case BuiltinOptions_TransposeOptions: {
16929	value = new tflite::TransposeOptionsT (*reinterpret_cast<tflite::TransposeOptionsT *>(u.value));
16930	break;
16931	}
16932	case BuiltinOptions_ReducerOptions: {
16933	value = new tflite::ReducerOptionsT (*reinterpret_cast<tflite::ReducerOptionsT *>(u.value));
16934	break;
16935	}
16936	case BuiltinOptions_SubOptions: {
16937	value = new tflite::SubOptionsT (*reinterpret_cast<tflite::SubOptionsT *>(u.value));
16938	break;
16939	}
16940	case BuiltinOptions_DivOptions: {
16941	value = new tflite::DivOptionsT (*reinterpret_cast<tflite::DivOptionsT *>(u.value));
16942	break;
16943	}
16944	case BuiltinOptions_SqueezeOptions: {
16945	value = new tflite::SqueezeOptionsT (*reinterpret_cast<tflite::SqueezeOptionsT *>(u.value));
16946	break;
16947	}
16948	case BuiltinOptions_SequenceRNNOptions: {
16949	value = new tflite::SequenceRNNOptionsT (*reinterpret_cast<tflite::SequenceRNNOptionsT *>(u.value));
16950	break;
16951	}
16952	case BuiltinOptions_StridedSliceOptions: {
16953	value = new tflite::StridedSliceOptionsT (*reinterpret_cast<tflite::StridedSliceOptionsT *>(u.value));
16954	break;
16955	}
16956	case BuiltinOptions_ExpOptions: {
16957	value = new tflite::ExpOptionsT (*reinterpret_cast<tflite::ExpOptionsT *>(u.value));
16958	break;
16959	}
16960	case BuiltinOptions_TopKV2Options: {
16961	value = new tflite::TopKV2OptionsT (*reinterpret_cast<tflite::TopKV2OptionsT *>(u.value));
16962	break;
16963	}
16964	case BuiltinOptions_SplitOptions: {
16965	value = new tflite::SplitOptionsT (*reinterpret_cast<tflite::SplitOptionsT *>(u.value));
16966	break;
16967	}
16968	case BuiltinOptions_LogSoftmaxOptions: {
16969	value = new tflite::LogSoftmaxOptionsT (*reinterpret_cast<tflite::LogSoftmaxOptionsT *>(u.value));
16970	break;
16971	}
16972	case BuiltinOptions_CastOptions: {
16973	value = new tflite::CastOptionsT (*reinterpret_cast<tflite::CastOptionsT *>(u.value));
16974	break;
16975	}
16976	case BuiltinOptions_DequantizeOptions: {
16977	value = new tflite::DequantizeOptionsT (*reinterpret_cast<tflite::DequantizeOptionsT *>(u.value));
16978	break;
16979	}
16980	case BuiltinOptions_MaximumMinimumOptions: {
16981	value = new tflite::MaximumMinimumOptionsT (*reinterpret_cast<tflite::MaximumMinimumOptionsT *>(u.value));
16982	break;
16983	}
16984	case BuiltinOptions_ArgMaxOptions: {
16985	value = new tflite::ArgMaxOptionsT (*reinterpret_cast<tflite::ArgMaxOptionsT *>(u.value));
16986	break;
16987	}
16988	case BuiltinOptions_LessOptions: {
16989	value = new tflite::LessOptionsT (*reinterpret_cast<tflite::LessOptionsT *>(u.value));
16990	break;
16991	}
16992	case BuiltinOptions_NegOptions: {
16993	value = new tflite::NegOptionsT (*reinterpret_cast<tflite::NegOptionsT *>(u.value));
16994	break;
16995	}
16996	case BuiltinOptions_PadV2Options: {
16997	value = new tflite::PadV2OptionsT (*reinterpret_cast<tflite::PadV2OptionsT *>(u.value));
16998	break;
16999	}
17000	case BuiltinOptions_GreaterOptions: {
17001	value = new tflite::GreaterOptionsT (*reinterpret_cast<tflite::GreaterOptionsT *>(u.value));
17002	break;
17003	}
17004	case BuiltinOptions_GreaterEqualOptions: {
17005	value = new tflite::GreaterEqualOptionsT (*reinterpret_cast<tflite::GreaterEqualOptionsT *>(u.value));
17006	break;
17007	}
17008	case BuiltinOptions_LessEqualOptions: {
17009	value = new tflite::LessEqualOptionsT (*reinterpret_cast<tflite::LessEqualOptionsT *>(u.value));
17010	break;
17011	}
17012	case BuiltinOptions_SelectOptions: {
17013	value = new tflite::SelectOptionsT (*reinterpret_cast<tflite::SelectOptionsT *>(u.value));
17014	break;
17015	}
17016	case BuiltinOptions_SliceOptions: {
17017	value = new tflite::SliceOptionsT (*reinterpret_cast<tflite::SliceOptionsT *>(u.value));
17018	break;
17019	}
17020	case BuiltinOptions_TransposeConvOptions: {
17021	value = new tflite::TransposeConvOptionsT (*reinterpret_cast<tflite::TransposeConvOptionsT *>(u.value));
17022	break;
17023	}
17024	case BuiltinOptions_SparseToDenseOptions: {
17025	value = new tflite::SparseToDenseOptionsT (*reinterpret_cast<tflite::SparseToDenseOptionsT *>(u.value));
17026	break;
17027	}
17028	case BuiltinOptions_TileOptions: {
17029	value = new tflite::TileOptionsT (*reinterpret_cast<tflite::TileOptionsT *>(u.value));
17030	break;
17031	}
17032	case BuiltinOptions_ExpandDimsOptions: {
17033	value = new tflite::ExpandDimsOptionsT (*reinterpret_cast<tflite::ExpandDimsOptionsT *>(u.value));
17034	break;
17035	}
17036	case BuiltinOptions_EqualOptions: {
17037	value = new tflite::EqualOptionsT (*reinterpret_cast<tflite::EqualOptionsT *>(u.value));
17038	break;
17039	}
17040	case BuiltinOptions_NotEqualOptions: {
17041	value = new tflite::NotEqualOptionsT (*reinterpret_cast<tflite::NotEqualOptionsT *>(u.value));
17042	break;
17043	}
17044	case BuiltinOptions_ShapeOptions: {
17045	value = new tflite::ShapeOptionsT (*reinterpret_cast<tflite::ShapeOptionsT *>(u.value));
17046	break;
17047	}
17048	case BuiltinOptions_PowOptions: {
17049	value = new tflite::PowOptionsT (*reinterpret_cast<tflite::PowOptionsT *>(u.value));
17050	break;
17051	}
17052	case BuiltinOptions_ArgMinOptions: {
17053	value = new tflite::ArgMinOptionsT (*reinterpret_cast<tflite::ArgMinOptionsT *>(u.value));
17054	break;
17055	}
17056	case BuiltinOptions_FakeQuantOptions: {
17057	value = new tflite::FakeQuantOptionsT (*reinterpret_cast<tflite::FakeQuantOptionsT *>(u.value));
17058	break;
17059	}
17060	case BuiltinOptions_PackOptions: {
17061	value = new tflite::PackOptionsT (*reinterpret_cast<tflite::PackOptionsT *>(u.value));
17062	break;
17063	}
17064	case BuiltinOptions_LogicalOrOptions: {
17065	value = new tflite::LogicalOrOptionsT (*reinterpret_cast<tflite::LogicalOrOptionsT *>(u.value));
17066	break;
17067	}
17068	case BuiltinOptions_OneHotOptions: {
17069	value = new tflite::OneHotOptionsT (*reinterpret_cast<tflite::OneHotOptionsT *>(u.value));
17070	break;
17071	}
17072	case BuiltinOptions_LogicalAndOptions: {
17073	value = new tflite::LogicalAndOptionsT (*reinterpret_cast<tflite::LogicalAndOptionsT *>(u.value));
17074	break;
17075	}
17076	case BuiltinOptions_LogicalNotOptions: {
17077	value = new tflite::LogicalNotOptionsT (*reinterpret_cast<tflite::LogicalNotOptionsT *>(u.value));
17078	break;
17079	}
17080	case BuiltinOptions_UnpackOptions: {
17081	value = new tflite::UnpackOptionsT (*reinterpret_cast<tflite::UnpackOptionsT *>(u.value));
17082	break;
17083	}
17084	case BuiltinOptions_FloorDivOptions: {
17085	value = new tflite::FloorDivOptionsT (*reinterpret_cast<tflite::FloorDivOptionsT *>(u.value));
17086	break;
17087	}
17088	case BuiltinOptions_SquareOptions: {
17089	value = new tflite::SquareOptionsT (*reinterpret_cast<tflite::SquareOptionsT *>(u.value));
17090	break;
17091	}
17092	case BuiltinOptions_ZerosLikeOptions: {
17093	value = new tflite::ZerosLikeOptionsT (*reinterpret_cast<tflite::ZerosLikeOptionsT *>(u.value));
17094	break;
17095	}
17096	case BuiltinOptions_FillOptions: {
17097	value = new tflite::FillOptionsT (*reinterpret_cast<tflite::FillOptionsT *>(u.value));
17098	break;
17099	}
17100	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
17101	value = new tflite::BidirectionalSequenceLSTMOptionsT (*reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(u.value));
17102	break;
17103	}
17104	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
17105	value = new tflite::BidirectionalSequenceRNNOptionsT (*reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(u.value));
17106	break;
17107	}
17108	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
17109	value = new tflite::UnidirectionalSequenceLSTMOptionsT (*reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(u.value));
17110	break;
17111	}
17112	case BuiltinOptions_FloorModOptions: {
17113	value = new tflite::FloorModOptionsT (*reinterpret_cast<tflite::FloorModOptionsT *>(u.value));
17114	break;
17115	}
17116	case BuiltinOptions_RangeOptions: {
17117	value = new tflite::RangeOptionsT (*reinterpret_cast<tflite::RangeOptionsT *>(u.value));
17118	break;
17119	}
17120	case BuiltinOptions_ResizeNearestNeighborOptions: {
17121	value = new tflite::ResizeNearestNeighborOptionsT (*reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(u.value));
17122	break;
17123	}
17124	case BuiltinOptions_LeakyReluOptions: {
17125	value = new tflite::LeakyReluOptionsT (*reinterpret_cast<tflite::LeakyReluOptionsT *>(u.value));
17126	break;
17127	}
17128	case BuiltinOptions_SquaredDifferenceOptions: {
17129	value = new tflite::SquaredDifferenceOptionsT (*reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(u.value));
17130	break;
17131	}
17132	case BuiltinOptions_MirrorPadOptions: {
17133	value = new tflite::MirrorPadOptionsT (*reinterpret_cast<tflite::MirrorPadOptionsT *>(u.value));
17134	break;
17135	}
17136	case BuiltinOptions_AbsOptions: {
17137	value = new tflite::AbsOptionsT (*reinterpret_cast<tflite::AbsOptionsT *>(u.value));
17138	break;
17139	}
17140	case BuiltinOptions_SplitVOptions: {
17141	value = new tflite::SplitVOptionsT (*reinterpret_cast<tflite::SplitVOptionsT *>(u.value));
17142	break;
17143	}
17144	case BuiltinOptions_UniqueOptions: {
17145	value = new tflite::UniqueOptionsT (*reinterpret_cast<tflite::UniqueOptionsT *>(u.value));
17146	break;
17147	}
17148	case BuiltinOptions_ReverseV2Options: {
17149	value = new tflite::ReverseV2OptionsT (*reinterpret_cast<tflite::ReverseV2OptionsT *>(u.value));
17150	break;
17151	}
17152	case BuiltinOptions_AddNOptions: {
17153	value = new tflite::AddNOptionsT (*reinterpret_cast<tflite::AddNOptionsT *>(u.value));
17154	break;
17155	}
17156	case BuiltinOptions_GatherNdOptions: {
17157	value = new tflite::GatherNdOptionsT (*reinterpret_cast<tflite::GatherNdOptionsT *>(u.value));
17158	break;
17159	}
17160	case BuiltinOptions_CosOptions: {
17161	value = new tflite::CosOptionsT (*reinterpret_cast<tflite::CosOptionsT *>(u.value));
17162	break;
17163	}
17164	case BuiltinOptions_WhereOptions: {
17165	value = new tflite::WhereOptionsT (*reinterpret_cast<tflite::WhereOptionsT *>(u.value));
17166	break;
17167	}
17168	case BuiltinOptions_RankOptions: {
17169	value = new tflite::RankOptionsT (*reinterpret_cast<tflite::RankOptionsT *>(u.value));
17170	break;
17171	}
17172	case BuiltinOptions_ReverseSequenceOptions: {
17173	value = new tflite::ReverseSequenceOptionsT (*reinterpret_cast<tflite::ReverseSequenceOptionsT *>(u.value));
17174	break;
17175	}
17176	case BuiltinOptions_MatrixDiagOptions: {
17177	value = new tflite::MatrixDiagOptionsT (*reinterpret_cast<tflite::MatrixDiagOptionsT *>(u.value));
17178	break;
17179	}
17180	case BuiltinOptions_QuantizeOptions: {
17181	value = new tflite::QuantizeOptionsT (*reinterpret_cast<tflite::QuantizeOptionsT *>(u.value));
17182	break;
17183	}
17184	case BuiltinOptions_MatrixSetDiagOptions: {
17185	value = new tflite::MatrixSetDiagOptionsT (*reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(u.value));
17186	break;
17187	}
17188	case BuiltinOptions_HardSwishOptions: {
17189	value = new tflite::HardSwishOptionsT (*reinterpret_cast<tflite::HardSwishOptionsT *>(u.value));
17190	break;
17191	}
17192	case BuiltinOptions_IfOptions: {
17193	value = new tflite::IfOptionsT (*reinterpret_cast<tflite::IfOptionsT *>(u.value));
17194	break;
17195	}
17196	case BuiltinOptions_WhileOptions: {
17197	value = new tflite::WhileOptionsT (*reinterpret_cast<tflite::WhileOptionsT *>(u.value));
17198	break;
17199	}
17200	case BuiltinOptions_DepthToSpaceOptions: {
17201	value = new tflite::DepthToSpaceOptionsT (*reinterpret_cast<tflite::DepthToSpaceOptionsT *>(u.value));
17202	break;
17203	}
17204	case BuiltinOptions_NonMaxSuppressionV4Options: {
17205	value = new tflite::NonMaxSuppressionV4OptionsT (*reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(u.value));
17206	break;
17207	}
17208	case BuiltinOptions_NonMaxSuppressionV5Options: {
17209	value = new tflite::NonMaxSuppressionV5OptionsT (*reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(u.value));
17210	break;
17211	}
17212	case BuiltinOptions_ScatterNdOptions: {
17213	value = new tflite::ScatterNdOptionsT (*reinterpret_cast<tflite::ScatterNdOptionsT *>(u.value));
17214	break;
17215	}
17216	case BuiltinOptions_SelectV2Options: {
17217	value = new tflite::SelectV2OptionsT (*reinterpret_cast<tflite::SelectV2OptionsT *>(u.value));
17218	break;
17219	}
17220	case BuiltinOptions_DensifyOptions: {
17221	value = new tflite::DensifyOptionsT (*reinterpret_cast<tflite::DensifyOptionsT *>(u.value));
17222	break;
17223	}
17224	case BuiltinOptions_SegmentSumOptions: {
17225	value = new tflite::SegmentSumOptionsT (*reinterpret_cast<tflite::SegmentSumOptionsT *>(u.value));
17226	break;
17227	}
17228	case BuiltinOptions_BatchMatMulOptions: {
17229	value = new tflite::BatchMatMulOptionsT (*reinterpret_cast<tflite::BatchMatMulOptionsT *>(u.value));
17230	break;
17231	}
17232	case BuiltinOptions_CumsumOptions: {
17233	value = new tflite::CumsumOptionsT (*reinterpret_cast<tflite::CumsumOptionsT *>(u.value));
17234	break;
17235	}
17236	case BuiltinOptions_CallOnceOptions: {
17237	value = new tflite::CallOnceOptionsT (*reinterpret_cast<tflite::CallOnceOptionsT *>(u.value));
17238	break;
17239	}
17240	case BuiltinOptions_BroadcastToOptions: {
17241	value = new tflite::BroadcastToOptionsT (*reinterpret_cast<tflite::BroadcastToOptionsT *>(u.value));
17242	break;
17243	}
17244	case BuiltinOptions_Rfft2dOptions: {
17245	value = new tflite::Rfft2dOptionsT (*reinterpret_cast<tflite::Rfft2dOptionsT *>(u.value));
17246	break;
17247	}
17248	case BuiltinOptions_Conv3DOptions: {
17249	value = new tflite::Conv3DOptionsT (*reinterpret_cast<tflite::Conv3DOptionsT *>(u.value));
17250	break;
17251	}
17252	case BuiltinOptions_HashtableOptions: {
17253	value = new tflite::HashtableOptionsT (*reinterpret_cast<tflite::HashtableOptionsT *>(u.value));
17254	break;
17255	}
17256	case BuiltinOptions_HashtableFindOptions: {
17257	value = new tflite::HashtableFindOptionsT (*reinterpret_cast<tflite::HashtableFindOptionsT *>(u.value));
17258	break;
17259	}
17260	case BuiltinOptions_HashtableImportOptions: {
17261	value = new tflite::HashtableImportOptionsT (*reinterpret_cast<tflite::HashtableImportOptionsT *>(u.value));
17262	break;
17263	}
17264	case BuiltinOptions_HashtableSizeOptions: {
17265	value = new tflite::HashtableSizeOptionsT (*reinterpret_cast<tflite::HashtableSizeOptionsT *>(u.value));
17266	break;
17267	}
17268	default:
17269	break;
17270	}
17271	}
17272
17273	inline void BuiltinOptionsUnion::Reset() {
17274	switch (type) {
17275	case BuiltinOptions_Conv2DOptions: {
17276	auto ptr = reinterpret_cast<tflite::Conv2DOptionsT *>(value);
17277	delete ptr;
17278	break;
17279	}
17280	case BuiltinOptions_DepthwiseConv2DOptions: {
17281	auto ptr = reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(value);
17282	delete ptr;
17283	break;
17284	}
17285	case BuiltinOptions_ConcatEmbeddingsOptions: {
17286	auto ptr = reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(value);
17287	delete ptr;
17288	break;
17289	}
17290	case BuiltinOptions_LSHProjectionOptions: {
17291	auto ptr = reinterpret_cast<tflite::LSHProjectionOptionsT *>(value);
17292	delete ptr;
17293	break;
17294	}
17295	case BuiltinOptions_Pool2DOptions: {
17296	auto ptr = reinterpret_cast<tflite::Pool2DOptionsT *>(value);
17297	delete ptr;
17298	break;
17299	}
17300	case BuiltinOptions_SVDFOptions: {
17301	auto ptr = reinterpret_cast<tflite::SVDFOptionsT *>(value);
17302	delete ptr;
17303	break;
17304	}
17305	case BuiltinOptions_RNNOptions: {
17306	auto ptr = reinterpret_cast<tflite::RNNOptionsT *>(value);
17307	delete ptr;
17308	break;
17309	}
17310	case BuiltinOptions_FullyConnectedOptions: {
17311	auto ptr = reinterpret_cast<tflite::FullyConnectedOptionsT *>(value);
17312	delete ptr;
17313	break;
17314	}
17315	case BuiltinOptions_SoftmaxOptions: {
17316	auto ptr = reinterpret_cast<tflite::SoftmaxOptionsT *>(value);
17317	delete ptr;
17318	break;
17319	}
17320	case BuiltinOptions_ConcatenationOptions: {
17321	auto ptr = reinterpret_cast<tflite::ConcatenationOptionsT *>(value);
17322	delete ptr;
17323	break;
17324	}
17325	case BuiltinOptions_AddOptions: {
17326	auto ptr = reinterpret_cast<tflite::AddOptionsT *>(value);
17327	delete ptr;
17328	break;
17329	}
17330	case BuiltinOptions_L2NormOptions: {
17331	auto ptr = reinterpret_cast<tflite::L2NormOptionsT *>(value);
17332	delete ptr;
17333	break;
17334	}
17335	case BuiltinOptions_LocalResponseNormalizationOptions: {
17336	auto ptr = reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(value);
17337	delete ptr;
17338	break;
17339	}
17340	case BuiltinOptions_LSTMOptions: {
17341	auto ptr = reinterpret_cast<tflite::LSTMOptionsT *>(value);
17342	delete ptr;
17343	break;
17344	}
17345	case BuiltinOptions_ResizeBilinearOptions: {
17346	auto ptr = reinterpret_cast<tflite::ResizeBilinearOptionsT *>(value);
17347	delete ptr;
17348	break;
17349	}
17350	case BuiltinOptions_CallOptions: {
17351	auto ptr = reinterpret_cast<tflite::CallOptionsT *>(value);
17352	delete ptr;
17353	break;
17354	}
17355	case BuiltinOptions_ReshapeOptions: {
17356	auto ptr = reinterpret_cast<tflite::ReshapeOptionsT *>(value);
17357	delete ptr;
17358	break;
17359	}
17360	case BuiltinOptions_SkipGramOptions: {
17361	auto ptr = reinterpret_cast<tflite::SkipGramOptionsT *>(value);
17362	delete ptr;
17363	break;
17364	}
17365	case BuiltinOptions_SpaceToDepthOptions: {
17366	auto ptr = reinterpret_cast<tflite::SpaceToDepthOptionsT *>(value);
17367	delete ptr;
17368	break;
17369	}
17370	case BuiltinOptions_EmbeddingLookupSparseOptions: {
17371	auto ptr = reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(value);
17372	delete ptr;
17373	break;
17374	}
17375	case BuiltinOptions_MulOptions: {
17376	auto ptr = reinterpret_cast<tflite::MulOptionsT *>(value);
17377	delete ptr;
17378	break;
17379	}
17380	case BuiltinOptions_PadOptions: {
17381	auto ptr = reinterpret_cast<tflite::PadOptionsT *>(value);
17382	delete ptr;
17383	break;
17384	}
17385	case BuiltinOptions_GatherOptions: {
17386	auto ptr = reinterpret_cast<tflite::GatherOptionsT *>(value);
17387	delete ptr;
17388	break;
17389	}
17390	case BuiltinOptions_BatchToSpaceNDOptions: {
17391	auto ptr = reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(value);
17392	delete ptr;
17393	break;
17394	}
17395	case BuiltinOptions_SpaceToBatchNDOptions: {
17396	auto ptr = reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(value);
17397	delete ptr;
17398	break;
17399	}
17400	case BuiltinOptions_TransposeOptions: {
17401	auto ptr = reinterpret_cast<tflite::TransposeOptionsT *>(value);
17402	delete ptr;
17403	break;
17404	}
17405	case BuiltinOptions_ReducerOptions: {
17406	auto ptr = reinterpret_cast<tflite::ReducerOptionsT *>(value);
17407	delete ptr;
17408	break;
17409	}
17410	case BuiltinOptions_SubOptions: {
17411	auto ptr = reinterpret_cast<tflite::SubOptionsT *>(value);
17412	delete ptr;
17413	break;
17414	}
17415	case BuiltinOptions_DivOptions: {
17416	auto ptr = reinterpret_cast<tflite::DivOptionsT *>(value);
17417	delete ptr;
17418	break;
17419	}
17420	case BuiltinOptions_SqueezeOptions: {
17421	auto ptr = reinterpret_cast<tflite::SqueezeOptionsT *>(value);
17422	delete ptr;
17423	break;
17424	}
17425	case BuiltinOptions_SequenceRNNOptions: {
17426	auto ptr = reinterpret_cast<tflite::SequenceRNNOptionsT *>(value);
17427	delete ptr;
17428	break;
17429	}
17430	case BuiltinOptions_StridedSliceOptions: {
17431	auto ptr = reinterpret_cast<tflite::StridedSliceOptionsT *>(value);
17432	delete ptr;
17433	break;
17434	}
17435	case BuiltinOptions_ExpOptions: {
17436	auto ptr = reinterpret_cast<tflite::ExpOptionsT *>(value);
17437	delete ptr;
17438	break;
17439	}
17440	case BuiltinOptions_TopKV2Options: {
17441	auto ptr = reinterpret_cast<tflite::TopKV2OptionsT *>(value);
17442	delete ptr;
17443	break;
17444	}
17445	case BuiltinOptions_SplitOptions: {
17446	auto ptr = reinterpret_cast<tflite::SplitOptionsT *>(value);
17447	delete ptr;
17448	break;
17449	}
17450	case BuiltinOptions_LogSoftmaxOptions: {
17451	auto ptr = reinterpret_cast<tflite::LogSoftmaxOptionsT *>(value);
17452	delete ptr;
17453	break;
17454	}
17455	case BuiltinOptions_CastOptions: {
17456	auto ptr = reinterpret_cast<tflite::CastOptionsT *>(value);
17457	delete ptr;
17458	break;
17459	}
17460	case BuiltinOptions_DequantizeOptions: {
17461	auto ptr = reinterpret_cast<tflite::DequantizeOptionsT *>(value);
17462	delete ptr;
17463	break;
17464	}
17465	case BuiltinOptions_MaximumMinimumOptions: {
17466	auto ptr = reinterpret_cast<tflite::MaximumMinimumOptionsT *>(value);
17467	delete ptr;
17468	break;
17469	}
17470	case BuiltinOptions_ArgMaxOptions: {
17471	auto ptr = reinterpret_cast<tflite::ArgMaxOptionsT *>(value);
17472	delete ptr;
17473	break;
17474	}
17475	case BuiltinOptions_LessOptions: {
17476	auto ptr = reinterpret_cast<tflite::LessOptionsT *>(value);
17477	delete ptr;
17478	break;
17479	}
17480	case BuiltinOptions_NegOptions: {
17481	auto ptr = reinterpret_cast<tflite::NegOptionsT *>(value);
17482	delete ptr;
17483	break;
17484	}
17485	case BuiltinOptions_PadV2Options: {
17486	auto ptr = reinterpret_cast<tflite::PadV2OptionsT *>(value);
17487	delete ptr;
17488	break;
17489	}
17490	case BuiltinOptions_GreaterOptions: {
17491	auto ptr = reinterpret_cast<tflite::GreaterOptionsT *>(value);
17492	delete ptr;
17493	break;
17494	}
17495	case BuiltinOptions_GreaterEqualOptions: {
17496	auto ptr = reinterpret_cast<tflite::GreaterEqualOptionsT *>(value);
17497	delete ptr;
17498	break;
17499	}
17500	case BuiltinOptions_LessEqualOptions: {
17501	auto ptr = reinterpret_cast<tflite::LessEqualOptionsT *>(value);
17502	delete ptr;
17503	break;
17504	}
17505	case BuiltinOptions_SelectOptions: {
17506	auto ptr = reinterpret_cast<tflite::SelectOptionsT *>(value);
17507	delete ptr;
17508	break;
17509	}
17510	case BuiltinOptions_SliceOptions: {
17511	auto ptr = reinterpret_cast<tflite::SliceOptionsT *>(value);
17512	delete ptr;
17513	break;
17514	}
17515	case BuiltinOptions_TransposeConvOptions: {
17516	auto ptr = reinterpret_cast<tflite::TransposeConvOptionsT *>(value);
17517	delete ptr;
17518	break;
17519	}
17520	case BuiltinOptions_SparseToDenseOptions: {
17521	auto ptr = reinterpret_cast<tflite::SparseToDenseOptionsT *>(value);
17522	delete ptr;
17523	break;
17524	}
17525	case BuiltinOptions_TileOptions: {
17526	auto ptr = reinterpret_cast<tflite::TileOptionsT *>(value);
17527	delete ptr;
17528	break;
17529	}
17530	case BuiltinOptions_ExpandDimsOptions: {
17531	auto ptr = reinterpret_cast<tflite::ExpandDimsOptionsT *>(value);
17532	delete ptr;
17533	break;
17534	}
17535	case BuiltinOptions_EqualOptions: {
17536	auto ptr = reinterpret_cast<tflite::EqualOptionsT *>(value);
17537	delete ptr;
17538	break;
17539	}
17540	case BuiltinOptions_NotEqualOptions: {
17541	auto ptr = reinterpret_cast<tflite::NotEqualOptionsT *>(value);
17542	delete ptr;
17543	break;
17544	}
17545	case BuiltinOptions_ShapeOptions: {
17546	auto ptr = reinterpret_cast<tflite::ShapeOptionsT *>(value);
17547	delete ptr;
17548	break;
17549	}
17550	case BuiltinOptions_PowOptions: {
17551	auto ptr = reinterpret_cast<tflite::PowOptionsT *>(value);
17552	delete ptr;
17553	break;
17554	}
17555	case BuiltinOptions_ArgMinOptions: {
17556	auto ptr = reinterpret_cast<tflite::ArgMinOptionsT *>(value);
17557	delete ptr;
17558	break;
17559	}
17560	case BuiltinOptions_FakeQuantOptions: {
17561	auto ptr = reinterpret_cast<tflite::FakeQuantOptionsT *>(value);
17562	delete ptr;
17563	break;
17564	}
17565	case BuiltinOptions_PackOptions: {
17566	auto ptr = reinterpret_cast<tflite::PackOptionsT *>(value);
17567	delete ptr;
17568	break;
17569	}
17570	case BuiltinOptions_LogicalOrOptions: {
17571	auto ptr = reinterpret_cast<tflite::LogicalOrOptionsT *>(value);
17572	delete ptr;
17573	break;
17574	}
17575	case BuiltinOptions_OneHotOptions: {
17576	auto ptr = reinterpret_cast<tflite::OneHotOptionsT *>(value);
17577	delete ptr;
17578	break;
17579	}
17580	case BuiltinOptions_LogicalAndOptions: {
17581	auto ptr = reinterpret_cast<tflite::LogicalAndOptionsT *>(value);
17582	delete ptr;
17583	break;
17584	}
17585	case BuiltinOptions_LogicalNotOptions: {
17586	auto ptr = reinterpret_cast<tflite::LogicalNotOptionsT *>(value);
17587	delete ptr;
17588	break;
17589	}
17590	case BuiltinOptions_UnpackOptions: {
17591	auto ptr = reinterpret_cast<tflite::UnpackOptionsT *>(value);
17592	delete ptr;
17593	break;
17594	}
17595	case BuiltinOptions_FloorDivOptions: {
17596	auto ptr = reinterpret_cast<tflite::FloorDivOptionsT *>(value);
17597	delete ptr;
17598	break;
17599	}
17600	case BuiltinOptions_SquareOptions: {
17601	auto ptr = reinterpret_cast<tflite::SquareOptionsT *>(value);
17602	delete ptr;
17603	break;
17604	}
17605	case BuiltinOptions_ZerosLikeOptions: {
17606	auto ptr = reinterpret_cast<tflite::ZerosLikeOptionsT *>(value);
17607	delete ptr;
17608	break;
17609	}
17610	case BuiltinOptions_FillOptions: {
17611	auto ptr = reinterpret_cast<tflite::FillOptionsT *>(value);
17612	delete ptr;
17613	break;
17614	}
17615	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
17616	auto ptr = reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(value);
17617	delete ptr;
17618	break;
17619	}
17620	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
17621	auto ptr = reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(value);
17622	delete ptr;
17623	break;
17624	}
17625	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
17626	auto ptr = reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
17627	delete ptr;
17628	break;
17629	}
17630	case BuiltinOptions_FloorModOptions: {
17631	auto ptr = reinterpret_cast<tflite::FloorModOptionsT *>(value);
17632	delete ptr;
17633	break;
17634	}
17635	case BuiltinOptions_RangeOptions: {
17636	auto ptr = reinterpret_cast<tflite::RangeOptionsT *>(value);
17637	delete ptr;
17638	break;
17639	}
17640	case BuiltinOptions_ResizeNearestNeighborOptions: {
17641	auto ptr = reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(value);
17642	delete ptr;
17643	break;
17644	}
17645	case BuiltinOptions_LeakyReluOptions: {
17646	auto ptr = reinterpret_cast<tflite::LeakyReluOptionsT *>(value);
17647	delete ptr;
17648	break;
17649	}
17650	case BuiltinOptions_SquaredDifferenceOptions: {
17651	auto ptr = reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(value);
17652	delete ptr;
17653	break;
17654	}
17655	case BuiltinOptions_MirrorPadOptions: {
17656	auto ptr = reinterpret_cast<tflite::MirrorPadOptionsT *>(value);
17657	delete ptr;
17658	break;
17659	}
17660	case BuiltinOptions_AbsOptions: {
17661	auto ptr = reinterpret_cast<tflite::AbsOptionsT *>(value);
17662	delete ptr;
17663	break;
17664	}
17665	case BuiltinOptions_SplitVOptions: {
17666	auto ptr = reinterpret_cast<tflite::SplitVOptionsT *>(value);
17667	delete ptr;
17668	break;
17669	}
17670	case BuiltinOptions_UniqueOptions: {
17671	auto ptr = reinterpret_cast<tflite::UniqueOptionsT *>(value);
17672	delete ptr;
17673	break;
17674	}
17675	case BuiltinOptions_ReverseV2Options: {
17676	auto ptr = reinterpret_cast<tflite::ReverseV2OptionsT *>(value);
17677	delete ptr;
17678	break;
17679	}
17680	case BuiltinOptions_AddNOptions: {
17681	auto ptr = reinterpret_cast<tflite::AddNOptionsT *>(value);
17682	delete ptr;
17683	break;
17684	}
17685	case BuiltinOptions_GatherNdOptions: {
17686	auto ptr = reinterpret_cast<tflite::GatherNdOptionsT *>(value);
17687	delete ptr;
17688	break;
17689	}
17690	case BuiltinOptions_CosOptions: {
17691	auto ptr = reinterpret_cast<tflite::CosOptionsT *>(value);
17692	delete ptr;
17693	break;
17694	}
17695	case BuiltinOptions_WhereOptions: {
17696	auto ptr = reinterpret_cast<tflite::WhereOptionsT *>(value);
17697	delete ptr;
17698	break;
17699	}
17700	case BuiltinOptions_RankOptions: {
17701	auto ptr = reinterpret_cast<tflite::RankOptionsT *>(value);
17702	delete ptr;
17703	break;
17704	}
17705	case BuiltinOptions_ReverseSequenceOptions: {
17706	auto ptr = reinterpret_cast<tflite::ReverseSequenceOptionsT *>(value);
17707	delete ptr;
17708	break;
17709	}
17710	case BuiltinOptions_MatrixDiagOptions: {
17711	auto ptr = reinterpret_cast<tflite::MatrixDiagOptionsT *>(value);
17712	delete ptr;
17713	break;
17714	}
17715	case BuiltinOptions_QuantizeOptions: {
17716	auto ptr = reinterpret_cast<tflite::QuantizeOptionsT *>(value);
17717	delete ptr;
17718	break;
17719	}
17720	case BuiltinOptions_MatrixSetDiagOptions: {
17721	auto ptr = reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(value);
17722	delete ptr;
17723	break;
17724	}
17725	case BuiltinOptions_HardSwishOptions: {
17726	auto ptr = reinterpret_cast<tflite::HardSwishOptionsT *>(value);
17727	delete ptr;
17728	break;
17729	}
17730	case BuiltinOptions_IfOptions: {
17731	auto ptr = reinterpret_cast<tflite::IfOptionsT *>(value);
17732	delete ptr;
17733	break;
17734	}
17735	case BuiltinOptions_WhileOptions: {
17736	auto ptr = reinterpret_cast<tflite::WhileOptionsT *>(value);
17737	delete ptr;
17738	break;
17739	}
17740	case BuiltinOptions_DepthToSpaceOptions: {
17741	auto ptr = reinterpret_cast<tflite::DepthToSpaceOptionsT *>(value);
17742	delete ptr;
17743	break;
17744	}
17745	case BuiltinOptions_NonMaxSuppressionV4Options: {
17746	auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(value);
17747	delete ptr;
17748	break;
17749	}
17750	case BuiltinOptions_NonMaxSuppressionV5Options: {
17751	auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(value);
17752	delete ptr;
17753	break;
17754	}
17755	case BuiltinOptions_ScatterNdOptions: {
17756	auto ptr = reinterpret_cast<tflite::ScatterNdOptionsT *>(value);
17757	delete ptr;
17758	break;
17759	}
17760	case BuiltinOptions_SelectV2Options: {
17761	auto ptr = reinterpret_cast<tflite::SelectV2OptionsT *>(value);
17762	delete ptr;
17763	break;
17764	}
17765	case BuiltinOptions_DensifyOptions: {
17766	auto ptr = reinterpret_cast<tflite::DensifyOptionsT *>(value);
17767	delete ptr;
17768	break;
17769	}
17770	case BuiltinOptions_SegmentSumOptions: {
17771	auto ptr = reinterpret_cast<tflite::SegmentSumOptionsT *>(value);
17772	delete ptr;
17773	break;
17774	}
17775	case BuiltinOptions_BatchMatMulOptions: {
17776	auto ptr = reinterpret_cast<tflite::BatchMatMulOptionsT *>(value);
17777	delete ptr;
17778	break;
17779	}
17780	case BuiltinOptions_CumsumOptions: {
17781	auto ptr = reinterpret_cast<tflite::CumsumOptionsT *>(value);
17782	delete ptr;
17783	break;
17784	}
17785	case BuiltinOptions_CallOnceOptions: {
17786	auto ptr = reinterpret_cast<tflite::CallOnceOptionsT *>(value);
17787	delete ptr;
17788	break;
17789	}
17790	case BuiltinOptions_BroadcastToOptions: {
17791	auto ptr = reinterpret_cast<tflite::BroadcastToOptionsT *>(value);
17792	delete ptr;
17793	break;
17794	}
17795	case BuiltinOptions_Rfft2dOptions: {
17796	auto ptr = reinterpret_cast<tflite::Rfft2dOptionsT *>(value);
17797	delete ptr;
17798	break;
17799	}
17800	case BuiltinOptions_Conv3DOptions: {
17801	auto ptr = reinterpret_cast<tflite::Conv3DOptionsT *>(value);
17802	delete ptr;
17803	break;
17804	}
17805	case BuiltinOptions_HashtableOptions: {
17806	auto ptr = reinterpret_cast<tflite::HashtableOptionsT *>(value);
17807	delete ptr;
17808	break;
17809	}
17810	case BuiltinOptions_HashtableFindOptions: {
17811	auto ptr = reinterpret_cast<tflite::HashtableFindOptionsT *>(value);
17812	delete ptr;
17813	break;
17814	}
17815	case BuiltinOptions_HashtableImportOptions: {
17816	auto ptr = reinterpret_cast<tflite::HashtableImportOptionsT *>(value);
17817	delete ptr;
17818	break;
17819	}
17820	case BuiltinOptions_HashtableSizeOptions: {
17821	auto ptr = reinterpret_cast<tflite::HashtableSizeOptionsT *>(value);
17822	delete ptr;
17823	break;
17824	}
17825	default: break;
17826	}
17827	value = nullptr;
17828	type = BuiltinOptions_NONE;
17829	}
17830
17831	inline const tflite::Model GetModel(const* void *buf) {
17832	return flatbuffers::GetRoot<tflite::Model>(buf);
17833	}
17834
17835	inline const tflite::Model GetSizePrefixedModel(const* void *buf) {
17836	return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
17837	}
17838
17839	inline const char *ModelIdentifier() {
17840	return "TFL3";
17841	}
17842
17843	inline bool ModelBufferHasIdentifier(const void *buf) {
17844	return flatbuffers::BufferHasIdentifier(
17845	buf, ModelIdentifier());
17846	}
17847
17848	inline bool VerifyModelBuffer(
17849	flatbuffers::Verifier &verifier) {
17850	return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
17851	}
17852
17853	inline bool VerifySizePrefixedModelBuffer(
17854	flatbuffers::Verifier &verifier) {
17855	return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
17856	}
17857
17858	inline const char *ModelExtension() {
17859	return "tflite";
17860	}
17861
17862	inline void FinishModelBuffer(
17863	flatbuffers::FlatBufferBuilder &fbb,
17864	flatbuffers::Offset<tflite::Model> root) {
17865	fbb.Finish(root, ModelIdentifier());
17866	}
17867
17868	inline void FinishSizePrefixedModelBuffer(
17869	flatbuffers::FlatBufferBuilder &fbb,
17870	flatbuffers::Offset<tflite::Model> root) {
17871	fbb.FinishSizePrefixed(root, ModelIdentifier());
17872	}
17873
17874	inline std::unique_ptr<tflite::ModelT> UnPackModel(
17875	const void *buf,
17876	const flatbuffers::resolver_function_t res = nullptr*) {
17877	return std::unique_ptr<tflite::ModelT>(GetModel(buf)->UnPack(res));
17878	}
17879
17880	inline std::unique_ptr<tflite::ModelT> UnPackSizePrefixedModel(
17881	const void *buf,
17882	const flatbuffers::resolver_function_t res = nullptr*) {
17883	return std::unique_ptr<tflite::ModelT>(GetSizePrefixedModel(buf)->UnPack(res));
17884	}
17885
17886	} // namespace tflite
17887
17888	#endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
17889

Browse the source code of halide/build-apps/_deps/tflite-src/tensorflow/lite/schema/schema_generated.h